add key_action

added Kollisionserkennung

See merge request maximilian.ruhm/processing-projektarbeit!1

Lektion 2/If_Clauses/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Run Sketch",
+      "type": "shell",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "command": "D:\\UNI\\Semester_1\\Programmieren\\processing-4.3\\processing-java.exe",
+      "presentation": {
+        "echo": true,
+        "reveal": "always",
+        "focus": false,
+        "panel": "dedicated"
+      },
+      "args": [
+		"--force",
+		"--sketch=${workspaceRoot}",
+		"--output=${workspaceRoot}/out",
+		"--run"
+	  ],
+      "windows": {
+        "type": "process",
+        "args": [
+          "--force",
+          {
+            "value": "--sketch=${workspaceRoot}",
+            "quoting": "strong"
+          },
+          {
+            "value": "--output=${workspaceRoot}\\out",
+            "quoting": "strong"
+          },
+          "--run"
+        ]
+      }
+    }
+  ]
+}

Lektion 2/If_Clauses/If_Clauses.pde

@@ -0,0 +1,431 @@
+// Aufgaben
+
+/*
+1. Welcher Code ist korrekt? (Mehrere Antworten korrekt)
+    if(a != c){ }   ✔
+    if(true){ }     ✔
+    if(a <= b){ }   ✔
+    if(a % b = 0){ }
+    if(){ }
+2. Gegeben ist folgender Code. Welche(s) Zeichen muss an die Stelle ???, damit das Programm die richtige Ausgabe liefert?
+    
+    int alter = 16;
+    if (alter ??? 18) {
+    println("Volljährig");
+    } else {
+    println("Minderjährig");
+    }
+
+Die Zeichen ">=" müssen an die Stelle
+
+3. Welchen Datentyp muss die BEDINGUNG haben? Warum?
+
+Die Bedingung muss vom Datentyp "Boolean" sein.
+
+4. Warum ist es wichtig die Zeilen innerhalb einen Code-Blocks einzurücken?
+
+Übersichtlichkeit... 
+
+5. Wie viele else-Teile kann ein if-Teil haben?
+Einen.
+
+*/
+
+
+
+
+
+
+// Einfache if Anweisungen
+
+// Gegeben sei eine int-Variable foo. Wenn diese größer als 50 ist, soll "OK" ausgegeben werden.
+
+/*
+
+int foo = 75;
+
+if(foo > 50)
+{
+    println("okay\n");
+}
+*/
+
+// Gegeben seien zwei int-Variablen a und b. Wenn a um mindestens 10 größer ist als b, soll "a gewinnt" ausgegeben werden.
+int a = 50;
+int b = 40;
+
+/*
+// Die Differenz wird mit a-b berechnet. Dann wird geguckt ob diese größer als 10 ist
+if((a-b) > 10)
+{
+    println("a gewinnt\n");
+}
+
+*/
+// Gegeben seien vier float-Variablen a, b, c, d. Wenn die Summe von a und b größer ist als die Summe von c und d, dann soll "a/b gewinnen" ausgegeben werden
+/*
+float a = 25;
+float b = 30;
+float c = 5; 
+float d = 10;
+
+if((a+b) > (b+c))
+{
+    println("a/b gewinnen\n");
+}
+
+*/
+
+// Gegeben seien drei int-Variablen x, y, z. Wenn die Summe von x und y genau doppelt so groß ist wie z ist, soll "passt" ausgegeben werden.
+
+/*
+int x = 10;
+int y = 6;
+int z = 8;
+
+// Um zu gucken die Summe von x+y doppelt so groß ist, multipliziert man z mit zwei und guckt das Ergebnis gleich groß mit x+y ist.
+if((x+y) == (z * 2))
+{
+    println("passt\n");
+}
+*/
+
+// If else
+
+// Gegeben seien zwei int-Variablen z1 und z2. Wenn die zwei Zahlen gleich sind, soll "gleich" ausgegeben werden, sonst "ungleich".
+
+/*
+
+int z1 = 5;
+int z2 = 5;
+
+// Wenn z1 gleich z2 ist
+if(z1 == z2)
+{
+    println("gleich");
+}
+//Wenn irgendein anderer Fal eintritt
+else {
+    println("ungleich");
+}
+*/
+
+// Löse die obige Aufgabe, indem du im ersten If-Teil "ungleich" ausgibst und im Else-Teil "gleich". Passe dazu die Bedingung an.
+/*
+int z1 = 5;
+int z2 = 5;
+
+if(z1 != z2)
+{
+    println("ungleich");
+}
+else {
+    println("gleich");
+}
+
+*/
+// Gegeben sei die int-Variable zahl. Wenn die Zahl gerade ist, soll "gerade" ausgegeben werden, sonst "ungerade".
+/*
+int zahl = 4;
+
+// Der Modulo ist Quasi Restrechnung. Besteht kein Rest, wenn die Zahl durch 2 geteilt wird, ist die Zahl gerade.
+// Falls es einen Rest gibt, ist die Zahl ungerade
+if(zahl%2==0)
+{
+    println("gerade");
+}
+else {
+    println("ungerade");
+}
+
+*/
+// 3. Verschachteltes If
+
+
+// Gegeben seien drei int-Variablen a, b und x. Wenn x zwischen den Zahlen a und b liegt,
+// sollst du "drin" auf der Konsole ausgeben. Geh davon aus, dass a kleiner als b ist!
+
+/*
+int a = 5;
+int b = 10;
+int x = 8;
+
+Wenn x größer als und kleiner als b ist, befindet sich x in der Range
+if(x > a )
+{
+    if(x < b)
+    {
+        println("drin");
+    }
+}
+*/
+
+//4. Klausurnoten
+/*
+
+int punkte = 10;
+
+// Erziehlt der Teilnehmer 10 Punkte oder mehr hat dieser mit Auszeichnung bestanden
+if(punkte >= 10)
+{
+    println("Bestanden mit Auszeichnung");
+}
+// Erziehlt der Teilnehmer 5 Punkte oder mehr als hat dieser bestanden
+else if(punkte >= 5){
+    println("Bestanden! \nAuf Wiedersehen. \n ");
+}
+// In jedem anderen Fall hat der Teilnehmer nicht bestanden
+else {
+    println("Leider durchgefallen :( \nAuf Wiedersehen.\n");
+} 
+
+*/
+
+/* 5. Stehenbleiben
+Ändere das folgende Programm derart, dass der Ball stehenbleibt, sobald er die Mitte erreicht. */
+/*
+
+
+int x = 0;
+
+void draw() {
+   background(255);
+   ellipse(x, 50, 20, 20);
+
+   // width/2 ist der Mittelpunkt. Solange x also kleiner als der Mittelpunkt ist wird x incremented
+   if (x < width/2) {
+        x++;
+   }
+}
+*/
+
+// 6. Wachsen
+// Der Ball fliegt wiederholt von links nach rechts. Bei jedem Durchlauf soll der Ball etwas größer sein.
+
+
+
+/*
+int x;
+int counter;
+int wh = 5;
+
+void draw()
+{
+    background(255);
+    ellipse(x, height/2, wh, wh);
+
+    // Wenn größer gleich width ist, wird x zurückgesetzt und wh (Größe) mit 1.5 multipliziert. 
+    // Die verwendung von >= wird verwendet um Bugs verzubeugen, falls der einzige Tick, in welchem die Condition true ist, nicht registriert
+    if(x>=width)
+    {
+        x=0;
+        wh*= 1.5;
+    }
+    x++;
+}
+
+*/
+
+// 7. Wachsen 2
+// Ein mittig platzierter Kreis wird stetig größer, bis er den Rand des Fensters erreicht, dann beginnt er wieder als ein kleiner Kreis zu wachsen.
+
+/*
+int wh = 1 ;
+
+void draw()
+{
+    background(255);
+    ellipse(width/2, height/2, wh, wh);
+
+    // Wenn die Größe der Elipse größer als die Breite ist, dann wird die Größe zurückgesetzt 
+    // Für >= gilt die gleiche Begründung wie in der vorherigen Aufgabe
+    if(wh >= width)
+    {
+        wh = 1;
+    }
+
+    // Increment wh +1 für jeden Tick.
+    wh++;
+}
+*/
+
+// 8. Mutierender Mousezeiger
+// Folgendes Programm erzeugt einen Mauszeiger in Form eines Kreises. 
+// Verändere das Programm derart, dass in der rechten Bildschirmhäfte der Mauszeiger zur gefüllten, 
+// schwarzen Box wird (mittig zum Mauszeiger) und in der linken wieder zum leeren Kreis.
+
+/*
+int size = 20;
+
+void draw() {
+    background(255);
+    
+    // Ist die Mausposition größer als die Hälfte der Breite (Mittelpunkt), dann wird ein rectangle gezeichnet
+    if(mouseX > width/2)
+    {
+        fill(0, 0, 0, 255);
+        rect(mouseX-size/2, mouseY-size/2, size, size);
+    } 
+    // Sonst wird ein Kreis gezeichnet
+    else {
+        fill(0, 0, 0, 0);
+        ellipse(mouseX, mouseY, size, size);
+        
+    }
+}
+*/
+
+/*
+9. Timer
+Du möchtest ein Programm schreiben, dass jede Sekunde einen Punkt auf die Konsole schreibt 
+(verwende print statt println), d.h. nach 10 Sekunden siehst du:
+*/
+
+/* 
+
+int count = 0;
+int frameRate = 60;
+
+// Framerate in der main() (setup) Methode setzen
+void setup()
+{
+    frameRate(60);
+}
+
+
+void draw()
+{
+    // Pro Tick wird der counter incremented
+    count++;
+
+    // Wenn der Rest (Modulo) von count/frameRate = 0 ist, dann wird ein Punkt mithilfe der Print() funktion ausgegeben.
+    // Da kein Breakcharacter (\n) verwendet wird (Oder die println() Funktion) wird der dot in der gleichen Line ausgegeben
+    if(count%frameRate==0)
+    {
+        print(".");
+    }
+}
+*/
+
+/*
+10. Klausurnoten (if-else-if)
+Löse eine ähnliche Aufgabe wie die oben mit if-else-if. Du hast eine Punktzahl gegeben:
+
+0 - 10: Durchgefallen
+11 - 20: Naja
+21 - 30: Mittelgut
+31 - 40: Gut
+41 - 50: Super
+*/
+
+/*
+int punkte = 10;
+
+
+// Alle Punkte über 40 sind Super
+
+if(punkte > 40)
+{
+    println("Super");
+}
+else if (punkte > 30) {
+    println("Gut");
+}
+
+else if (punkte > 20) {
+    println("Mittelgut");
+}
+else if (punkte > 10) {
+    println("Naja");
+}
+else {
+    println("Durchgefallen");
+}
+
+*/
+
+/*
+11. Lauftext
+Schreibe eine Textanzeige, die bei Mausklick zum nächsten Wort wechselt. Das erste Wort ist "Hallo":
+
+Ergänze den Code, dass bei jedem Mausklick ein neues Wort angezeigt wird. 
+Nach "Hallo" kommt "mein", "Name", "ist", "Hase", "Tschüs". Danach geht es wieder von vorn los. 
+Nutze die Variable zustand und eine if-else-if Konstruktion.
+*/
+/*
+int zustand = 0;
+
+void setup() {
+   textAlign(CENTER);
+   textSize(20);
+}
+
+void mousePressed()
+{
+    zustand++;
+}
+
+void draw() {
+    background(0);
+
+    if (zustand == 0) {
+        text("Hallo", width/2, height/2);
+    }
+    else if (zustand == 1) {
+        text("mein", width/2, height/2);
+    }
+
+    else if (zustand == 2) {
+        text("Name", width/2, height/2);
+    }
+
+    else if (zustand == 3) {
+        text("ist", width/2, height/2);
+    }
+
+    else if (zustand == 4) {
+        text("Hase", width/2, height/2);
+    }
+
+    else {
+        text("Tschüs", width/2, height/2);
+    }
+}
+
+*/
+
+/*
+//Performantere Version
+// Dies liegt daran, dass die Abzweigung von else-if trees vom Compiler vorrausgerechnet werden. Dies geschieht nach einer Warscheinlichkeit die
+// Die der Compiler einem Branch zuweist. Wenn der Compiler den richtigen Branch guessed, dann gibt es keine Performanceeinbußen gering. 
+// Verschätzt sich der Compiler jedoch frisst das viel Performance. Deswegen kann man dem es dem Compiler einfacher machen und einen Array verwenden.
+int zustand;
+
+// Init string (const char*) array mit Strings für jedes Element
+String [] str =  {"Hallo", "mein", "Name", "ist", "Hase", "Tschüß"};
+
+// Call main() method
+void setup() {
+    size(500,500);
+    textAlign(CENTER);
+    textSize(width/5);
+}
+
+// Register mouse click
+void mousePressed()
+{
+    // Increment Zustand 
+    zustand++;
+}
+
+void draw() {
+    // Background schwarz setzen
+    background(0);
+
+    // Zustand zur array.length()-1 clampen.
+    // Würde man versuchenn ein Element auszulesen, welches bei einer Pos > (Array Length-1) liegt, würde man auf
+    // Eine Ram-Adress zugreifen, welche für eine andere Variable zugewiesen ist, was eine outofBoundsException hervorrufen würde.
+    zustand = constrain(zustand, 0, 5);
+    text(str[zustand], width/2, height/2);
+}
+*/

Lektion 2/If_Clauses/out/source/If_Clauses.java

@@ -0,0 +1,469 @@
+/* autogenerated by Processing revision 1293 on 2023-09-26 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class If_Clauses extends PApplet {
+
+// Aufgaben
+
+/*
+1. Welcher Code ist korrekt? (Mehrere Antworten korrekt)
+    if(a != c){ }   ✔
+    if(true){ }     ✔
+    if(a <= b){ }   ✔
+    if(a % b = 0){ }
+    if(){ }
+2. Gegeben ist folgender Code. Welche(s) Zeichen muss an die Stelle ???, damit das Programm die richtige Ausgabe liefert?
+    
+    int alter = 16;
+    if (alter ??? 18) {
+    println("Volljährig");
+    } else {
+    println("Minderjährig");
+    }
+
+Die Zeichen ">=" müssen an die Stelle
+
+3. Welchen Datentyp muss die BEDINGUNG haben? Warum?
+
+Die Bedingung muss vom Datentyp "Boolean" sein.
+
+4. Warum ist es wichtig die Zeilen innerhalb einen Code-Blocks einzurücken?
+
+Übersichtlichkeit... 
+
+5. Wie viele else-Teile kann ein if-Teil haben?
+Einen.
+
+*/
+
+
+
+
+
+
+// Einfache if Anweisungen
+
+// Gegeben sei eine int-Variable foo. Wenn diese größer als 50 ist, soll "OK" ausgegeben werden.
+
+/*
+
+int foo = 75;
+
+if(foo > 50)
+{
+    println("okay\n");
+}
+*/
+
+// Gegeben seien zwei int-Variablen a und b. Wenn a um mindestens 10 größer ist als b, soll "a gewinnt" ausgegeben werden.
+int a = 50;
+int b = 40;
+
+/*
+// Die Differenz wird mit a-b berechnet. Dann wird geguckt ob diese größer als 10 ist
+if((a-b) > 10)
+{
+    println("a gewinnt\n");
+}
+
+*/
+// Gegeben seien vier float-Variablen a, b, c, d. Wenn die Summe von a und b größer ist als die Summe von c und d, dann soll "a/b gewinnen" ausgegeben werden
+/*
+float a = 25;
+float b = 30;
+float c = 5; 
+float d = 10;
+
+if((a+b) > (b+c))
+{
+    println("a/b gewinnen\n");
+}
+
+*/
+
+// Gegeben seien drei int-Variablen x, y, z. Wenn die Summe von x und y genau doppelt so groß ist wie z ist, soll "passt" ausgegeben werden.
+
+/*
+int x = 10;
+int y = 6;
+int z = 8;
+
+// Um zu gucken die Summe von x+y doppelt so groß ist, multipliziert man z mit zwei und guckt das Ergebnis gleich groß mit x+y ist.
+if((x+y) == (z * 2))
+{
+    println("passt\n");
+}
+*/
+
+// If else
+
+// Gegeben seien zwei int-Variablen z1 und z2. Wenn die zwei Zahlen gleich sind, soll "gleich" ausgegeben werden, sonst "ungleich".
+
+/*
+
+int z1 = 5;
+int z2 = 5;
+
+// Wenn z1 gleich z2 ist
+if(z1 == z2)
+{
+    println("gleich");
+}
+//Wenn irgendein anderer Fal eintritt
+else {
+    println("ungleich");
+}
+*/
+
+// Löse die obige Aufgabe, indem du im ersten If-Teil "ungleich" ausgibst und im Else-Teil "gleich". Passe dazu die Bedingung an.
+/*
+int z1 = 5;
+int z2 = 5;
+
+if(z1 != z2)
+{
+    println("ungleich");
+}
+else {
+    println("gleich");
+}
+
+*/
+// Gegeben sei die int-Variable zahl. Wenn die Zahl gerade ist, soll "gerade" ausgegeben werden, sonst "ungerade".
+/*
+int zahl = 4;
+
+// Der Modulo ist Quasi Restrechnung. Besteht kein Rest, wenn die Zahl durch 2 geteilt wird, ist die Zahl gerade.
+// Falls es einen Rest gibt, ist die Zahl ungerade
+if(zahl%2==0)
+{
+    println("gerade");
+}
+else {
+    println("ungerade");
+}
+
+*/
+// 3. Verschachteltes If
+
+
+// Gegeben seien drei int-Variablen a, b und x. Wenn x zwischen den Zahlen a und b liegt,
+// sollst du "drin" auf der Konsole ausgeben. Geh davon aus, dass a kleiner als b ist!
+
+/*
+int a = 5;
+int b = 10;
+int x = 8;
+
+Wenn x größer als und kleiner als b ist, befindet sich x in der Range
+if(x > a )
+{
+    if(x < b)
+    {
+        println("drin");
+    }
+}
+*/
+
+//4. Klausurnoten
+/*
+
+int punkte = 10;
+
+// Erziehlt der Teilnehmer 10 Punkte oder mehr hat dieser mit Auszeichnung bestanden
+if(punkte >= 10)
+{
+    println("Bestanden mit Auszeichnung");
+}
+// Erziehlt der Teilnehmer 5 Punkte oder mehr als hat dieser bestanden
+else if(punkte >= 5){
+    println("Bestanden! \nAuf Wiedersehen. \n ");
+}
+// In jedem anderen Fall hat der Teilnehmer nicht bestanden
+else {
+    println("Leider durchgefallen :( \nAuf Wiedersehen.\n");
+} 
+
+*/
+
+/* 5. Stehenbleiben
+Ändere das folgende Programm derart, dass der Ball stehenbleibt, sobald er die Mitte erreicht. */
+/*
+
+
+int x = 0;
+
+void draw() {
+   background(255);
+   ellipse(x, 50, 20, 20);
+
+   // width/2 ist der Mittelpunkt. Solange x also kleiner als der Mittelpunkt ist wird x incremented
+   if (x < width/2) {
+        x++;
+   }
+}
+*/
+
+// 6. Wachsen
+// Der Ball fliegt wiederholt von links nach rechts. Bei jedem Durchlauf soll der Ball etwas größer sein.
+
+
+
+/*
+int x;
+int counter;
+int wh = 5;
+
+void draw()
+{
+    background(255);
+    ellipse(x, height/2, wh, wh);
+
+    // Wenn größer gleich width ist, wird x zurückgesetzt und wh (Größe) mit 1.5 multipliziert. 
+    // Die verwendung von >= wird verwendet um Bugs verzubeugen, falls der einzige Tick, in welchem die Condition true ist, nicht registriert
+    if(x>=width)
+    {
+        x=0;
+        wh*= 1.5;
+    }
+    x++;
+}
+
+*/
+
+// 7. Wachsen 2
+// Ein mittig platzierter Kreis wird stetig größer, bis er den Rand des Fensters erreicht, dann beginnt er wieder als ein kleiner Kreis zu wachsen.
+
+/*
+int wh = 1 ;
+
+void draw()
+{
+    background(255);
+    ellipse(width/2, height/2, wh, wh);
+
+    // Wenn die Größe der Elipse größer als die Breite ist, dann wird die Größe zurückgesetzt 
+    // Für >= gilt die gleiche Begründung wie in der vorherigen Aufgabe
+    if(wh >= width)
+    {
+        wh = 1;
+    }
+
+    // Increment wh +1 für jeden Tick.
+    wh++;
+}
+*/
+
+// 8. Mutierender Mousezeiger
+// Folgendes Programm erzeugt einen Mauszeiger in Form eines Kreises. 
+// Verändere das Programm derart, dass in der rechten Bildschirmhäfte der Mauszeiger zur gefüllten, 
+// schwarzen Box wird (mittig zum Mauszeiger) und in der linken wieder zum leeren Kreis.
+
+/*
+int size = 20;
+
+void draw() {
+    background(255);
+    
+    // Ist die Mausposition größer als die Hälfte der Breite (Mittelpunkt), dann wird ein rectangle gezeichnet
+    if(mouseX > width/2)
+    {
+        fill(0, 0, 0, 255);
+        rect(mouseX-size/2, mouseY-size/2, size, size);
+    } 
+    // Sonst wird ein Kreis gezeichnet
+    else {
+        fill(0, 0, 0, 0);
+        ellipse(mouseX, mouseY, size, size);
+        
+    }
+}
+*/
+
+/*
+9. Timer
+Du möchtest ein Programm schreiben, dass jede Sekunde einen Punkt auf die Konsole schreibt 
+(verwende print statt println), d.h. nach 10 Sekunden siehst du:
+*/
+
+/* 
+
+int count = 0;
+int frameRate = 60;
+
+// Framerate in der main() (setup) Methode setzen
+void setup()
+{
+    frameRate(60);
+}
+
+
+void draw()
+{
+    // Pro Tick wird der counter incremented
+    count++;
+
+    // Wenn der Rest (Modulo) von count/frameRate = 0 ist, dann wird ein Punkt mithilfe der Print() funktion ausgegeben.
+    // Da kein Breakcharacter (\n) verwendet wird (Oder die println() Funktion) wird der dot in der gleichen Line ausgegeben
+    if(count%frameRate==0)
+    {
+        print(".");
+    }
+}
+*/
+
+/*
+10. Klausurnoten (if-else-if)
+Löse eine ähnliche Aufgabe wie die oben mit if-else-if. Du hast eine Punktzahl gegeben:
+
+0 - 10: Durchgefallen
+11 - 20: Naja
+21 - 30: Mittelgut
+31 - 40: Gut
+41 - 50: Super
+*/
+
+/*
+int punkte = 10;
+
+
+// Alle Punkte über 40 sind Super
+
+if(punkte > 40)
+{
+    println("Super");
+}
+else if (punkte > 30) {
+    println("Gut");
+}
+
+else if (punkte > 20) {
+    println("Mittelgut");
+}
+else if (punkte > 10) {
+    println("Naja");
+}
+else {
+    println("Durchgefallen");
+}
+
+*/
+
+/*
+11. Lauftext
+Schreibe eine Textanzeige, die bei Mausklick zum nächsten Wort wechselt. Das erste Wort ist "Hallo":
+
+Ergänze den Code, dass bei jedem Mausklick ein neues Wort angezeigt wird. 
+Nach "Hallo" kommt "mein", "Name", "ist", "Hase", "Tschüs". Danach geht es wieder von vorn los. 
+Nutze die Variable zustand und eine if-else-if Konstruktion.
+*/
+/*
+int zustand = 0;
+
+void setup() {
+   textAlign(CENTER);
+   textSize(20);
+}
+
+void mousePressed()
+{
+    zustand++;
+}
+
+void draw() {
+    background(0);
+
+    if (zustand == 0) {
+        text("Hallo", width/2, height/2);
+    }
+    else if (zustand == 1) {
+        text("mein", width/2, height/2);
+    }
+
+    else if (zustand == 2) {
+        text("Name", width/2, height/2);
+    }
+
+    else if (zustand == 3) {
+        text("ist", width/2, height/2);
+    }
+
+    else if (zustand == 4) {
+        text("Hase", width/2, height/2);
+    }
+
+    else {
+        text("Tschüs", width/2, height/2);
+    }
+}
+
+*/
+
+/*
+//Performantere Version
+// Dies liegt daran, dass die Abzweigung von else-if trees vom Compiler vorrausgerechnet werden. Dies geschieht nach einer Warscheinlichkeit die
+// Die der Compiler einem Branch zuweist. Wenn der Compiler den richtigen Branch guessed, dann gibt es keine Performanceeinbußen gering. 
+// Verschätzt sich der Compiler jedoch frisst das viel Performance. Deswegen kann man dem es dem Compiler einfacher machen und einen Array verwenden.
+*/
+int zustand;
+
+// Init string (const char*) array mit Strings für jedes Element
+String [] str =  {"Hallo", "mein", "Name", "ist", "Hase", "Tschüß"};
+
+// Call main() method
+public void setup() {
+    /* size commented out by preprocessor */;
+    textAlign(CENTER);
+    textSize(width/5);
+}
+
+// Register mouse click
+public void mousePressed()
+{
+    // Increment Zustand 
+    zustand++;
+}
+
+public void draw() {
+    // Background schwarz setzen
+    background(0);
+
+    // Wenn der Zustand kleiner als 6 ist Verwende Zustand den Wert eines Elementes zu bekommen.
+    // Würde man versuchenn ein Element auszulesen, welches bei einer Pos > (Array Length-1) liegt, würde man auf
+    // Eine Ram-Adress zugreifen, welche für eine andere Variable zugewiesen ist, was eine outofBoundsException hervorrufen würde.
+    //if(zustand < 6)
+        //text(str[zustand], width/2, height/2);
+
+    // Wenn das Element out of Bounds wäre, wird das letzte Element verwendet.
+    //else
+    zustand = constrain(zustand, 0, 5);
+    text(str[zustand], width/2, height/2);
+     
+        //text(str[5], width/2, height/2);
+
+}
+
+
+  public void settings() { size(500, 500); }
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "If_Clauses" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion 2/Key_action/arrow_key_move/arrow_key_move.pde

@@ -0,0 +1,26 @@
+int x = 0;//Position x
+int y = 0;//Positon y
+
+void setup () {
+  size(300, 300);
+  //Startposition Mitte
+  x = width /2;
+  y = height /2;
+}
+
+void draw () {
+  background(255);
+  ellipse(x, y, 40, 40);
+}
+
+void keyPressed() {
+  if (keyCode == RIGHT) {
+    x +=10; // Kreis nach rechts
+  } else if (keyCode == LEFT) {
+    x -= 10; // Kreis nach links
+  } else if (keyCode == DOWN) {
+    y +=10; // Kreis nach unten
+  } else if (keyCode == UP) {
+    y -= 10; // Kreis nach oben
+  }
+}

Lektion 2/Key_action/black_white_1/black_white_1.pde

@@ -0,0 +1,15 @@
+int bg = 200;//bg = background
+
+void draw() {
+  background(bg);
+  rectMode(CENTER);
+  rect(50, 50, 40, 40);
+}
+
+void keyPressed() {
+  bg = 0;
+}
+
+void mousePressed() {
+  bg = 255;
+}

Lektion 2/Key_action/black_white_2/black_white_2.pde

@@ -0,0 +1,21 @@
+boolean bg_is_white = true;
+
+void draw() {
+  if(bg_is_white) {
+    background(255);
+    fill(0);
+  } else {
+    background(0);
+    fill(255);
+  }
+  ellipseMode(CENTER);
+  ellipse(50, 50, 50, 50);
+}
+
+void keyPressed() {
+  bg_is_white = false;
+}
+
+void mousePressed() {
+  bg_is_white = true;
+}

Lektion 2/Kollisionserkennung/1_FarbButtons/FarbButtons.pde

@@ -0,0 +1,64 @@
+int size = 150;
+
+void setup() {
+    size(570, 570);
+    noStroke();
+    background(220);
+}
+
+void draw() {
+    int x1 = width / 2 - size / 2;
+    int y1 = 105 - size / 2;
+    int x2 = x1;
+    int y2 = 285 - size / 2;
+    int x3 = x1;
+    int y3 = 475 - size / 2;
+    
+    // setze Buttons
+    drawButton(x1, y1, color(255, 0, 0), "Rot");
+    drawButton(x2, y2, color(0, 255, 0), "Grün");
+    drawButton(x3, y3, color(0, 0, 255), "Blau");
+    
+    // Klick außerhalb der Elemente
+    if (!(x1 <= mouseX && 
+        y1 <= mouseY && 
+        mouseX <= x1 + size && 
+        mouseY <= y1 + size) && 
+        !(x2 <= mouseX && 
+        y2 <= mouseY && 
+        mouseX <= x2 + size && 
+        mouseY <= y2 + size) && 
+        !(x3 <= mouseX && 
+        y3 <= mouseY && 
+        mouseX <= x3 + size && 
+        mouseY <= y3 + size)) {
+        
+        if (mousePressed) {
+            background(220);
+        }
+    }
+}
+
+void drawButton(int x, int y, color paint, String title) {
+    // setze Füllfarbe ...
+    if (x <= mouseX && 
+        y <= mouseY && 
+        mouseX <= x + size && 
+        mouseY <= y + size) {
+        if (mousePressed) {
+            background(paint);
+        }
+        
+        fill(200);
+    } 
+    // setze Rechteck
+    rect(x, y, size, size);
+    
+    // setze Text
+    fill(0);
+    textAlign(CENTER);
+    text(title, x + size / 2, y + size / 2);
+    
+    
+    fill(255);
+}

Lektion 2/Kollisionserkennung/1_FarbButtons/out/source/FarbButtons.java

@@ -0,0 +1,93 @@
+/* autogenerated by Processing revision 1293 on 2023-09-27 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class FarbButtons extends PApplet {
+
+int size = 150;
+
+public void setup() {
+    /* size commented out by preprocessor */;
+    noStroke();
+    background(220);
+}
+
+public void draw() {
+    int x1 = width / 2 - size / 2;
+    int y1 = 105 - size / 2;
+    int x2 = x1;
+    int y2 = 285 - size / 2;
+    int x3 = x1;
+    int y3 = 475 - size / 2;
+    
+    drawButton(x1, y1, color(255, 0, 0), "Rot");
+    drawButton(x2, y2, color(0, 255, 0), "Grün");
+    drawButton(x3, y3, color(0, 0, 255), "Blau");
+    
+    // Klick außerhalb der Elemente
+    if (!(x1 <= mouseX && 
+        y1 <= mouseY && 
+        mouseX <= x1 + size && 
+        mouseY <= y1 + size) && 
+        !(x2 <= mouseX && 
+        y2 <= mouseY && 
+        mouseX <= x2 + size && 
+        mouseY <= y2 + size) && 
+        !(x3 <= mouseX && 
+        y3 <= mouseY && 
+        mouseX <= x3 + size && 
+        mouseY <= y3 + size)) {
+        
+        if (mousePressed) {
+            background(220);
+        }
+    }
+}
+
+public void drawButton(int x, int y, int paint, String title) {
+    // setze Füllfarbe ...
+    if (x <= mouseX && 
+        y <= mouseY && 
+        mouseX <= x + size && 
+        mouseY <= y + size) {
+        if (mousePressed) {
+            background(paint);
+        }
+        
+        fill(200);
+    } 
+    // setze Rechteck
+    rect(x, y, size, size);
+    
+    // setze Text
+    fill(0);
+    textAlign(CENTER);
+    text(title, x + size / 2, y + size / 2);
+    
+    
+    fill(255);
+}
+
+
+  public void settings() { size(570, 570); }
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "FarbButtons" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion 2/Kollisionserkennung/2_rectMode/out/source/rectMode.java

@@ -0,0 +1,75 @@
+/* autogenerated by Processing revision 1293 on 2023-09-27 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class rectMode extends PApplet {
+
+int size = 150; // Durchmesser
+
+public void setup() {
+    /* size commented out by preprocessor */;
+    noStroke();
+    background(220);
+}
+
+public void draw() {
+    drawButton(width / 2, 105, color(255, 0, 0), "Rot");
+    drawButton(width / 2, 285, color(0, 255, 0), "Grün");
+    drawButton(width / 2, 475, color(0, 0, 255), "Blau");
+    
+    // Klick außerhalb der Elemente
+    if (dist(mouseX, mouseY, width / 2, 105) > size / 2 && 
+        dist(mouseX, mouseY, width / 2, 285) > size / 2 && 
+        dist(mouseX, mouseY, width / 2, 475) > size / 2) {
+        
+        if (mousePressed) {
+            background(220);
+        }
+    }
+}
+
+public void drawButton(int x, int y, int paint, String title) {
+    // setze Füllfarbe ...
+    if (dist(mouseX, mouseY, x, y) < size / 2) {
+        if (mousePressed) {
+            background(paint);
+        }
+        
+        fill(200);
+    } 
+    // setze Rechteck
+    rectMode(CENTER);
+    rect(x, y, size, size);
+    
+    // setze Text
+    fill(0);
+    textAlign(CENTER);
+    text(title, x, y);
+    
+    
+    fill(255);
+}
+
+
+  public void settings() { size(570, 570); }
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "rectMode" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion 2/Kollisionserkennung/2_rectMode/rectMode.pde

@@ -0,0 +1,46 @@
+int size = 150; // Durchmesser
+
+void setup() {
+    size(570, 570);
+    noStroke();
+    background(220);
+}
+
+void draw() {
+    // setze Buttons
+    drawButton(width / 2, 105, color(255, 0, 0), "Rot");
+    drawButton(width / 2, 285, color(0, 255, 0), "Grün");
+    drawButton(width / 2, 475, color(0, 0, 255), "Blau");
+    
+    // Klick außerhalb der Elemente
+    if (dist(mouseX, mouseY, width / 2, 105) > size / 2 && 
+        dist(mouseX, mouseY, width / 2, 285) > size / 2 && 
+        dist(mouseX, mouseY, width / 2, 475) > size / 2) {
+        
+        if (mousePressed) {
+            background(220);
+        }
+    }
+}
+
+void drawButton(int x, int y, color paint, String title) {
+    // setze Füllfarbe ...
+    if (dist(mouseX, mouseY, x, y) < size / 2) {
+        if (mousePressed) {
+            background(paint);
+        }
+        
+        fill(200);
+    } 
+    // setze Rechteck
+    rectMode(CENTER);
+    rect(x, y, size, size);
+    
+    // setze Text
+    fill(0);
+    textAlign(CENTER);
+    text(title, x, y);
+    
+    
+    fill(255);
+}

Lektion 2/Kollisionserkennung/3_UeberlappendeButtons/UeberlappendeButtons.pde

@@ -0,0 +1,35 @@
+int x1 = 200;
+int y1 = 100;
+int x2 = 100;
+int y2 = 200;
+int size = 200;
+
+void setup() {
+    size(800, 600);
+}
+
+void draw() {
+    // setze hintergrund
+    background(255);
+    noFill();
+    
+    // setze rechtecke
+    rect(x1, y1, size, size);
+    rect(x2, y2, size, size);
+    
+    // pruefung ob mauszeiger in rechteck ist
+    boolean isInRect1 = mouseX >= x1 && mouseY >= y1 && mouseX <= x1 + size && mouseY <= y1 + size;
+    boolean isInRect2 = mouseX >= x2 && mouseY >= y2 && mouseX <= x2 + size && mouseY <= y2 + size;
+    
+   if (isInRect1 && isInRect2) { // mauszeiger in schnittmenge
+      fill(0, 0, 255);
+   } else if (isInRect1) { // mauszeiger in rechteck 1
+      fill(255, 0, 0);
+   } else if (isInRect2) { // mauszeiger in rechteck 2
+      fill(0, 255, 0);
+   } else {
+      noFill(); // mauszeiger außerhalb der rechtecke
+   }
+    
+    ellipse(mouseX, mouseY, 20, 20);
+}

Lektion 2/Kollisionserkennung/3_UeberlappendeButtons/out/source/UeberlappendeButtons.java

@@ -0,0 +1,65 @@
+/* autogenerated by Processing revision 1293 on 2023-09-27 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class UeberlappendeButtons extends PApplet {
+
+int x1 = 200;
+int y1 = 100;
+int x2 = 100;
+int y2 = 200;
+int size = 200;
+
+public void setup() {
+    /* size commented out by preprocessor */;
+}
+
+public void draw() {
+    // setze hintergrund
+    background(255);
+    noFill();
+    
+    // setze rechtecke
+    rect(x1, y1, size, size);
+    rect(x2, y2, size, size);
+    
+    // pruefung ob mauszeiger in rechteck ist
+    boolean isInRect1 = mouseX >= x1 && mouseY >= y1 && mouseX <= x1 + size && mouseY <= y1 + size;
+    boolean isInRect2 = mouseX >= x2 && mouseY >= y2 && mouseX <= x2 + size && mouseY <= y2 + size;
+    
+   if (isInRect1 && isInRect2) { // mauszeiger in schnittmenge
+      fill(0, 0, 255);
+   } else if (isInRect1) { // mauszeiger in rechteck 1
+      fill(255, 0, 0);
+   } else if (isInRect2) { // mauszeiger in rechteck 2
+      fill(0, 255, 0);
+   } else {
+      noFill(); // mauszeiger außerhalb der rechtecke
+   }
+    
+    ellipse(mouseX, mouseY, 20, 20);
+}
+
+
+  public void settings() { size(800, 600); }
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "UeberlappendeButtons" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion 2/Kollisionserkennung/4_KollisionPunktLinie/KollisionPunktLinie.pde

@@ -0,0 +1,28 @@
+float ax = 50; // x-Position von Punkt a
+
+float bx = 5; // x-Position des Startpunkts der Linie b
+float bwidth = 30; // Breite der Linie b
+
+void draw() {
+    background(0);
+    strokeWeight(5);
+    
+    stroke(0,255,0);
+    point(ax, ax); // setze punkt
+    
+    if (bx + bwidth >= ax && bx <= ax) { // wenn linie innerhalb x von punkt
+        stroke(255, 0, 0); // setze farbe auf rot
+    } else {
+        stroke(255); // setze farbe auf weiß
+    }
+    
+    line(bx, 60, bx + bwidth, 60); // setze linie
+    
+    if (keyPressed) {
+        if(keyCode == LEFT) {
+            bx -= 2;
+    } else if (keyCode == RIGHT) {
+            bx += 2;
+    }
+}
+}

Lektion 2/Kollisionserkennung/4_KollisionPunktLinie/out/source/KollisionPunktLinie.java

@@ -0,0 +1,56 @@
+/* autogenerated by Processing revision 1293 on 2023-09-27 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class KollisionPunktLinie extends PApplet {
+
+float ax = 50; // x-Position von Punkt a
+
+float bx = 5; // x-Position des Startpunkts der Linie b
+float bwidth = 30; // Breite der Linie b
+
+public void draw() {
+    background(0);
+    strokeWeight(5);
+    
+    stroke(0,255,0);
+    point(ax, ax);
+    
+    if (bx + bwidth >= ax && bx <= ax) {
+        stroke(255, 0, 0);
+    } else {
+        stroke(255);
+    }
+    
+    line(bx, 60, bx + bwidth, 60);
+    
+    if (keyPressed) {
+        if(keyCode == LEFT) {
+            bx -= 2;
+    } else if (keyCode == RIGHT) {
+            bx += 2;
+    }
+}
+}
+
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "KollisionPunktLinie" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion 2/Kollisionserkennung/5_KollisionLinieLinie/KollisionLinieLinie.pde

@@ -0,0 +1,33 @@
+float ax = 60; // x-Position des Startpunkts der Linie a
+float awidth = 30; // Breite der Linie a
+
+float bx = 5; // x-Position des Startpunkts der Linie b
+float bwidth = 40; // Breite der Linie b
+
+void setup() {
+    size(150, 100);
+}
+
+void draw() {
+    background(0);
+    strokeWeight(4);
+    
+    stroke(0,255,0);
+    line(ax, 50, ax + awidth, 50); // setze linie
+    
+    stroke(255);
+    
+    if (bx + bwidth >= ax && bx <=  ax + awidth) { // wenn line b unter linie a
+        stroke(255, 0, 0); // setze farbe auf rot
+    }
+    
+    line(bx, 60, bx + bwidth, 60);
+    
+    if (keyPressed) {
+        if(keyCode == LEFT) {
+            bx -= 2;
+    } else if (keyCode == RIGHT) {
+            bx += 2;
+    }
+}
+}

Lektion 2/Kollisionserkennung/5_KollisionLinieLinie/out/source/KollisionLinieLinie.java

@@ -0,0 +1,63 @@
+/* autogenerated by Processing revision 1293 on 2023-09-27 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class KollisionLinieLinie extends PApplet {
+
+float ax = 60; // x-Position des Startpunkts der Linie a
+float awidth = 30; // Breite der Linie a
+
+float bx = 5; // x-Position des Startpunkts der Linie b
+float bwidth = 40; // Breite der Linie b
+
+public void setup() {
+    /* size commented out by preprocessor */;
+}
+
+public void draw() {
+    background(0);
+    strokeWeight(4);
+    
+    stroke(0,255,0);
+    line(ax, 50, ax + awidth, 50);
+    
+    stroke(255);
+    
+    if (bx + bwidth >= ax && bx <=  ax + awidth) {
+        stroke(255, 0, 0);
+    }
+    
+    line(bx, 60, bx + bwidth, 60);
+    
+    if (keyPressed) {
+        if(keyCode == LEFT) {
+            bx -= 2;
+    } else if (keyCode == RIGHT) {
+            bx += 2;
+    }
+}
+}
+
+
+  public void settings() { size(150, 100); }
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "KollisionLinieLinie" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion_3/While_Loops/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Run Sketch",
+      "type": "shell",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "command": "/home/borsi/Documents/Uni/1_Semester/Prg/processing-4.3/processing-java",
+      "presentation": {
+        "echo": true,
+        "reveal": "always",
+        "focus": false,
+        "panel": "dedicated"
+      },
+      "args": [
+		"--force",
+		"--sketch=${workspaceRoot}",
+		"--output=${workspaceRoot}/out",
+		"--run"
+	  ],
+      "windows": {
+        "type": "process",
+        "args": [
+          "--force",
+          {
+            "value": "--sketch=${workspaceRoot}",
+            "quoting": "strong"
+          },
+          {
+            "value": "--output=${workspaceRoot}\\out",
+            "quoting": "strong"
+          },
+          "--run"
+        ]
+      }
+    }
+  ]
+}

Lektion_3/While_Loops/While_Loops.pde

@@ -0,0 +1,117 @@
+/*
+1. Wozu benötigt einen Schleife eine Schleifenbedingung?
+Wenn es keine Schleifenbedingung gibt, läuft die Schleife nicht.
+
+2. Warum ist die Schleifenaktion wichtig? Was passiert, wenn es keine Schleifenaktion gibt?
+Nichts??????
+
+3. Was bedeutet kopfgesteuert und fußgesteuert in Bezug auf Schleifen?
+Bei einer kopfgesteuerten Schleife, wird die Abbruchbedingung vor dem Durchlauf geprüft, bei einer fußgesteuerten nach dem Durchlauf.
+Dh. eine Fußgesteuerte Schleife läuft immer min. 1x, eine Kopfgegesteuerte >= 0x 
+
+4. Ist dieser Code korrekt? Ist er sinnvoll? Begründe.int zaehler = 0;
+    while(true) {
+    println("Hi");
+    zaehler++;
+    }
+
+    Syntaktisch ist der Code Korrekt. Er enthält allerding eine Endlosschleife.
+    die Variable Zähler ist eine Laufvariable, welche die Durchläufe zählt.
+
+
+
+----------------------------------------Aufgaben-----------------------------
+*/
+
+/*
+1.  2er-Schritte
+    Schreibe eine While-Schleife, 
+    die eine Variable zaehler in 2er-Schritten von 0 bis 10 hochzählt. 
+    In jeder Runde gibst du den Wert auf der Konsole aus.
+
+
+int zaehler = 0;
+
+while (zaehler <= 10) {
+    println(zaehler);
+    zaehler+=2;
+}
+*/
+
+/*
+2. 2er-Schritte rückwärts
+Schreibe eine While-Schleife, die eine Variable zaehler in 2er-Schritten von 10 bis 0 runterzählt. 
+In jeder Runde gibst du den Wert auf der Konsole aus.
+
+int zaehler = 10;
+
+while (zaehler >= 0) {
+    println(zaehler);
+    zaehler-=2;
+}
+*/
+
+
+/*
+3. Hash-Zeichen
+Schreibe eine While-Schleife, die eine vorgegebene Anzahl von #-Zeichen (engl. hash) auf der Konsole ausgibt. Die Anzahl wird durch 
+eine Variable festgelegen.
+
+int anzahl = 3;
+
+// jetzt dein Code...
+In dem Code oben sollen also 3 Hashes ausgegeben werden. Wenn man die Variable anzahl auf 7 setzt, sollen 7 Hashes ausgegeben werden.
+
+Hinweis: Veränder die Variable anzahl nicht. Führe stattdessen eine zweite Variable i ein, um deine While-Schleife zu steuern.
+
+Auf der Konsole sollte nach Start dies stehen:
+
+###
+
+int i = 0;
+int anzahl = 3;
+while (i < anzahl) {
+    i++;
+    print("#");
+}
+*/
+
+/*
+4. Viele Quadrate
+Zeichne drei Quadrate nebeneinander. 
+Das erste liegt bei (10, 40) und ist 20x20 Pixel groß. Das nächste liegt mit 10 Pixeln Abstand rechts daneben,
+das dritte wieder 10 Pixel rechts davon. Verwende eine While-Schleife, 
+sodass du mit einer kleinen Änderung auch 5 oder 2 Quadrate zeichnen kannst.
+
+
+
+
+size(1000,1000);
+int anzahl = 5;
+int i = 0;
+int x = 0;
+int size = 20;
+while (i < anzahl) {
+    i++;
+    rect(x, 0, size, size);
+    x+=10 + size;
+}
+*/
+
+/*
+5. Teiler
+Schreibe alle Zahlen im Bereich {1, ..., 49} auf die Konsole, die durch 7 teilbar sind, und alle, die durch 13 teilbar sind.
+Verwende eine While-Schleife.
+*/
+
+/*
+int i = 1;
+
+while(i < 50)    {
+    if(i%7==0)
+    {
+        println(i);
+    }
+    i++;
+}
+*/

Lektion_3/While_Loops/out/source/While_Loops.java

@@ -0,0 +1,147 @@
+/* autogenerated by Processing revision 1293 on 2023-10-05 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class While_Loops extends PApplet {
+
+  public void setup() {
+/*
+1. Wozu benötigt einen Schleife eine Schleifenbedingung?
+Wenn es keine Schleifenbedingung gibt, läuft die Schleife nicht.
+
+2. Warum ist die Schleifenaktion wichtig? Was passiert, wenn es keine Schleifenaktion gibt?
+Nichts??????
+
+3. Was bedeutet kopfgesteuert und fußgesteuert in Bezug auf Schleifen?
+Bei einer kopfgesteuerten Schleife, wird die Abbruchbedingung vor dem Durchlauf geprüft, bei einer fußgesteuerten nach dem Durchlauf.
+Dh. eine Fußgesteuerte Schleife läuft immer min. 1x, eine Kopfgegesteuerte >= 0x 
+
+4. Ist dieser Code korrekt? Ist er sinnvoll? Begründe.int zaehler = 0;
+    while(true) {
+    println("Hi");
+    zaehler++;
+    }
+
+    Syntaktisch ist der Code Korrekt. Er enthält allerding eine Endlosschleife.
+    die Variable Zähler ist eine Laufvariable, welche die Durchläufe zählt.
+
+
+
+----------------------------------------Aufgaben-----------------------------
+*/
+
+/*
+1.  2er-Schritte
+    Schreibe eine While-Schleife, 
+    die eine Variable zaehler in 2er-Schritten von 0 bis 10 hochzählt. 
+    In jeder Runde gibst du den Wert auf der Konsole aus.
+
+
+int zaehler = 0;
+
+while (zaehler <= 10) {
+    println(zaehler);
+    zaehler+=2;
+}
+*/
+
+/*
+2. 2er-Schritte rückwärts
+Schreibe eine While-Schleife, die eine Variable zaehler in 2er-Schritten von 10 bis 0 runterzählt. 
+In jeder Runde gibst du den Wert auf der Konsole aus.
+
+int zaehler = 10;
+
+while (zaehler >= 0) {
+    println(zaehler);
+    zaehler-=2;
+}
+*/
+
+
+/*
+3. Hash-Zeichen
+Schreibe eine While-Schleife, die eine vorgegebene Anzahl von #-Zeichen (engl. hash) auf der Konsole ausgibt. Die Anzahl wird durch 
+eine Variable festgelegen.
+
+int anzahl = 3;
+
+// jetzt dein Code...
+In dem Code oben sollen also 3 Hashes ausgegeben werden. Wenn man die Variable anzahl auf 7 setzt, sollen 7 Hashes ausgegeben werden.
+
+Hinweis: Veränder die Variable anzahl nicht. Führe stattdessen eine zweite Variable i ein, um deine While-Schleife zu steuern.
+
+Auf der Konsole sollte nach Start dies stehen:
+
+###
+
+int i = 0;
+int anzahl = 3;
+while (i < anzahl) {
+    i++;
+    print("#");
+}
+*/
+
+/*
+4. Viele Quadrate
+Zeichne drei Quadrate nebeneinander. 
+Das erste liegt bei (10, 40) und ist 20x20 Pixel groß. Das nächste liegt mit 10 Pixeln Abstand rechts daneben,
+das dritte wieder 10 Pixel rechts davon. Verwende eine While-Schleife, 
+sodass du mit einer kleinen Änderung auch 5 oder 2 Quadrate zeichnen kannst.
+
+
+
+
+size(1000,1000);
+int anzahl = 5;
+int i = 0;
+int x = 0;
+int size = 20;
+while (i < anzahl) {
+    i++;
+    rect(x, 0, size, size);
+    x+=10 + size;
+}
+*/
+
+/*
+5. Teiler
+Schreibe alle Zahlen im Bereich {1, ..., 49} auf die Konsole, die durch 7 teilbar sind, und alle, die durch 13 teilbar sind.
+Verwende eine While-Schleife.
+*/
+/*
+*/
+int i = 1;
+
+while(i < 50)    {
+    if(i%7==0)
+    {
+        println(i);
+    }
+    i++;
+}
+
+    noLoop();
+  }
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "While_Loops" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}

Lektion_4/Multidimensionale_Arrays/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Run Sketch",
+      "type": "shell",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "command": "/home/borsi/Documents/Uni/1_Semester/Prg/processing-4.3/processing-java",
+      "presentation": {
+        "echo": true,
+        "reveal": "always",
+        "focus": false,
+        "panel": "dedicated"
+      },
+      "args": [
+		"--force",
+		"--sketch=${workspaceRoot}",
+		"--output=${workspaceRoot}/out",
+		"--run"
+	  ],
+      "windows": {
+        "type": "process",
+        "args": [
+          "--force",
+          {
+            "value": "--sketch=${workspaceRoot}",
+            "quoting": "strong"
+          },
+          {
+            "value": "--output=${workspaceRoot}\\out",
+            "quoting": "strong"
+          },
+          "--run"
+        ]
+      }
+    }
+  ]
+}

Lektion_4/Multidimensionale_Arrays/Multidimensionale_Arrays.pde

@@ -0,0 +1,99 @@
+/*
+
+
+1. Tic Tac Toe
+Gegeben ist folgender Code:
+
+String tictactoe [] [] = new String [3][3];
+
+Befülle die Arrays mit Daten. Erweitere den Code so, damit das Programm in der Konsole folgendes ausgibt:
+
+        xox
+        oxo
+        xox
+
+
+*/
+
+/*
+String tictactoe [] [] = {{"x", "o", "x"},  {"o", "x", "o"}, {"x", "o", "x"}};
+
+for(int x = 0; x < 3; x++)     {
+    for(int y = 0; y < 3; y++)     {
+        print(tictactoe[x][y]);
+    }
+    print("\n");
+}
+*/
+
+/*
+2. Tabelle mit Studierenden
+Gegeben ist folgender Code:
+
+String studierende[] [] = new String [3][3];
+int anzahlMing = 0;
+int anzahlIni = 0;
+
+Befülle die Arrays mit Daten. Im ersten Feld der zweiten Dimension des Arrays sollen Vornamen stehen, im zweiten Nachnamen und im dritten der Studiengang (Ming, INI, MMP, etc.).
+Somit soll jede Zeile die Daten eines Studierenden enthalten. Lass dir die Daten zeilenweise ausgeben und füge ein Trennzeichen zwischen den Spalten ein (z.N. | oder ~).
+
+Erweitere den Code so, damit das Programm in der Konsole (zum Beispiel) folgendes ausgibt:
+
+Mara | Meier | Ming
+Tom | Sawyer | INI
+Luke | Skywalker | Ming
+
+Anzahl der Studierenden: 3
+Anzahl der Ming-Studierenden: 2
+Anzahl der INI-Studierenden: 1
+*/
+
+/*
+Ein Multidimensionaler Array ist nichts anderes als ein Array in einem Array.
+Um in diesem Fall die Möglichkeit zu bieten >= 0 Studenten einzutragen, wird für die erste Dimensionen
+die ArrayList benutzt. 
+Die ArrayList ist anders als der Array nicht an die Größe bei der Initialisierung gebunden. 
+Da wir wissen das ein Student immer drei Werte hat, wird für die zweite Dimension ein normaler Array benutzt. 
+
+Dieser Array wird dann in die ArrayList eingefügt. Zusammen bilden beide Arrays (Unter der Haube ist die ArrayList
+auch ein Array) einen Multidimensionalen Array.it 
+*/
+
+/*
+int anzahlMing = 0;
+int anzahlIni = 0;
+
+ArrayList<String[]> studenten = new ArrayList<String[]>();
+
+void setup() {
+    addStudent("Mara", "Meier", "Ming");
+    addStudent("Tom", "Sawyer", "INI");
+    addStudent("Luke", "Skywalker", "Ming");
+
+    drucken();
+}
+
+void addStudent(String vorname, String name, String studiengang)   {
+    String student[] = {vorname, name, studiengang};
+    studenten.add(student);
+    
+    if(studiengang == "Ming")
+        anzahlMing++;
+    else 
+        anzahlIni++;
+}
+
+void drucken()  {
+    for(int i = 0; i < studenten.size(); i++)   {
+        print(studenten.get(i)[0] + " | " + studenten.get(i)[1] + " | " + studenten.get(i)[2] + "\n");
+    }
+
+    print(
+        "\n" + 
+        "Anzahl der Studierenden: " + (anzahlMing + anzahlIni) + "\n" + 
+        "Anzahl der Ming-Studierenden: " + anzahlMing + "\n" +
+        "Anzahl der INI-Studierenden: " + anzahlIni + "\n"
+    );
+}
+
+*/

Lektion_4/Multidimensionale_Arrays/out/source/Multidimensionale_Arrays.java

@@ -0,0 +1,112 @@
+/* autogenerated by Processing revision 1293 on 2023-10-05 */
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class Multidimensionale_Arrays extends PApplet {
+
+/*
+
+
+1. Tic Tac Toe
+Gegeben ist folgender Code:
+
+String tictactoe [] [] = new String [3][3];
+
+Befülle die Arrays mit Daten. Erweitere den Code so, damit das Programm in der Konsole folgendes ausgibt:
+
+        xox
+        oxo
+        xox
+
+
+*/
+
+/*
+String tictactoe [] [] = {{"x", "o", "x"},  {"o", "x", "o"}, {"x", "o", "x"}};
+
+for(int x = 0; x < 3; x++)     {
+    for(int y = 0; y < 3; y++)     {
+        print(tictactoe[x][y]);
+    }
+    print("\n");
+}
+*/
+
+/*
+2. Tabelle mit Studierenden
+Gegeben ist folgender Code:
+
+String studierende[] [] = new String [3][3];
+int anzahlMing = 0;
+int anzahlIni = 0;
+
+Befülle die Arrays mit Daten. Im ersten Feld der zweiten Dimension des Arrays sollen Vornamen stehen, im zweiten Nachnamen und im dritten der Studiengang (Ming, INI, MMP, etc.).
+Somit soll jede Zeile die Daten eines Studierenden enthalten. Lass dir die Daten zeilenweise ausgeben und füge ein Trennzeichen zwischen den Spalten ein (z.N. | oder ~).
+
+Erweitere den Code so, damit das Programm in der Konsole (zum Beispiel) folgendes ausgibt:
+
+Mara | Meier | Ming
+Tom | Sawyer | INI
+Luke | Skywalker | Ming
+
+Anzahl der Studierenden: 3
+Anzahl der Ming-Studierenden: 2
+Anzahl der INI-Studierenden: 1
+*/
+int anzahlMing = 0;
+int anzahlIni = 0;
+
+ArrayList<String[]> studenten = new ArrayList<String[]>();
+
+public void setup() {
+    addStudent("Mara", "Meier", "Ming");
+    addStudent("Tom", "Sawyer", "INI");
+    addStudent("Luke", "Skywalker", "Ming");
+
+    drucken();
+}
+
+public void addStudent(String vorname, String name, String studiengang)   {
+    String student[] = {vorname, name, studiengang};
+    studenten.add(student);
+    
+    if(studiengang == "Ming")
+        anzahlMing++;
+    else 
+        anzahlIni++;
+}
+
+public void drucken()  {
+    for(int i = 0; i < studenten.size(); i++)   {
+        print(studenten.get(i)[0] + " | " + studenten.get(i)[1] + " | " + studenten.get(i)[2] + "\n");
+    }
+
+    print(
+        "\n" + 
+        "Anzahl der Studierenden: " + (anzahlMing + anzahlIni) + "\n" + 
+        "Anzahl der Ming-Studierenden: " + anzahlMing + "\n" +
+        "Anzahl der INI-Studierenden: " + anzahlIni + "\n"
+    );
+}
+
+
+  static public void main(String[] passedArgs) {
+    String[] appletArgs = new String[] { "Multidimensionale_Arrays" };
+    if (passedArgs != null) {
+      PApplet.main(concat(appletArgs, passedArgs));
+    } else {
+      PApplet.main(appletArgs);
+    }
+  }
+}