Level 5 A 3

Author: Marcel Kaufmann

tutorial/Level5/CatcherTutorialLevel5A3/Catcher.pde

@@ -0,0 +1,22 @@
+class Catcher {
+  PShape c;
+  float yPos;
+  float xPos;
+  float catcherWidth;
+  float catcherHeight;
+
+  public Catcher( ) {
+    catcherWidth = gameWidth/8;
+    catcherHeight = gameHeight/100;
+    rectMode(CENTER);
+    fill(255);
+    c = createShape(RECT, 0, 0, catcherWidth, catcherHeight);
+    yPos = gameHeight-(gameHeight/8);
+    xPos = gameWidth/2;
+  }
+
+  void draw() {
+    xPos = playerPosX;
+    shape(c, xPos, yPos);
+  }
+}

tutorial/Level5/CatcherTutorialLevel5A3/CatcherTutorialLevel5A3.pde

@@ -0,0 +1,20 @@
+float playerPosX;
+float gameHeight;
+float gameWidth;
+Game game;
+
+void setup() {
+  size(400, 640);
+  //fullScreen(P2D);
+  gameWidth = width;
+  gameHeight = height;
+  game = new Game();
+}
+
+void draw() {
+  background(50);
+  if (mousePressed) {
+    playerPosX = mouseX;
+  }
+  game.execute();
+}

tutorial/Level5/CatcherTutorialLevel5A3/Coin.pde

@@ -0,0 +1,27 @@
+class Coin {
+  PShape c;
+  float xPos;
+  float yPos;
+  float coinWidth;
+  float coinHeigth;
+
+  public Coin() {
+    ellipseMode(CENTER);
+    init();
+  }
+
+  void init( ) {
+    coinWidth = gameHeight/50;
+    coinHeigth = gameHeight/50;
+    xPos = random(coinWidth, (gameWidth-1)-coinWidth);
+    yPos = -coinHeigth;
+    c = createShape(ELLIPSE, 0, 0, coinWidth, coinHeigth);
+    c.setFill(color(255, 255, 0));
+  }
+
+  void display( ) {
+    shape(c, xPos, -coinWidth);
+    c.translate(0, 2);
+    yPos += 2;
+  }
+}

tutorial/Level5/CatcherTutorialLevel5A3/Game.pde

@@ -0,0 +1,55 @@
+import java.util.Stack;
+
+class Game {
+  int lives;
+  ArrayList<Coin> coinListInGame = new ArrayList<Coin>();
+  Stack<Coin> waitingStack = new Stack();
+
+  Catcher catcher;
+
+  int interval = 1000;
+  int savedTime = millis();
+
+  public Game () {
+    lives = 5;
+    catcher = new Catcher();
+  }
+
+
+  void execute() {
+    catcher.draw();
+    if (isTimeForNextOne()) {
+      if (waitingStack.empty()) {
+        waitingStack.push(new Coin());
+      }
+      Coin newCoin = waitingStack.pop();
+      coinListInGame.add(newCoin);
+    }
+
+    for (int i = 0; i < coinListInGame.size(); i++) {
+      Coin currentCoin = coinListInGame.get(i);
+      boolean isOut = isInOutZone(currentCoin);
+      if (isOut) {
+        coinListInGame.remove(currentCoin);
+        currentCoin.init();
+        waitingStack.push(currentCoin);
+        lives --;
+      } else {
+        currentCoin.display();
+      }
+    }
+  }
+
+  boolean isInOutZone(Coin coin) {
+    return coin.yPos + coin.coinHeigth/2 >= gameHeight-1;
+  }
+
+  boolean isTimeForNextOne( ) {
+    int currentTime = millis();
+    if (savedTime + interval < currentTime) {
+      savedTime = currentTime;
+      return true;
+    }
+    return false;
+  }
+}

tutorial/Level5/Processing_Tutorial_Level_#5-CatcherGameTutorial.md

@@ -32,5 +32,13 @@ println("Lives: "+ lives); // Innerhalb der zyklischen Ausführung
 
 [Mögliche Lösung](https://github.com/Flocksserver/CatcherTutorial/blob/master/tutorial/Level5/CatcherTutorialLevel5A2)
 
+### Aufgabe 3
+1. Yeah! Wir haben einen dauerhaften Objektregen. Leider ist dieser sehr ineffizient, da der Speicher mit sehr viel Objekten vollgeschrieben wird.
+> Exkurs: In Java gibt es den *garbage collector*, der Objekte, die im Speicher existieren aber nicht mehr referenziert sind automatisch entfernt. Durch dein Entfernen der Objekte aus der *ingame*-Liste hast du keinen Zugriff mehr drauf (nicht mehr referenziert). Demnach könnte sich der *garbage collector* um das Entfernen der Objekte kümmern. Bist du also fein raus? Theoretisch ja, praktisch nein! Es ist *guter Stil* effizient zu programmieren, denn der *garbage collector* ist ein Feature der JVM (Java Virtual Machine). Wenn du beispielsweise das nächste mal etwas in C++ programmierst, hilft es dir gleich mit dem scharfen Blick zur Effizienz zu programmieren.
+
+2. Passe deine Implementierung an, sodass das Objekt bei Kollision mit dem unteren Bildschirmrand nicht nur aus der *ingame*-Liste entfernt, sondern gleich wieder dem Stack hinzugefügt wird. Hast du im herunterfallenden Objekt globale Variablen die du wieder zurücksetzen musst? Bestimmt! Erstelle eine Funktion in der Klasse, die alle relevanten Variablen wieder auf den initialen Zustand zurücksetzt.
+
+[Mögliche Lösung](https://github.com/Flocksserver/CatcherTutorial/blob/master/tutorial/Level5/CatcherTutorialLevel5A3)
+
 # Nächstes Level
 Hier geht es weiter zum [nächsten Level :arrow_right:](https://github.com/Flocksserver/CatcherTutorial/blob/master/tutorial/Level6/Processing_Tutorial_Level_%236-CatcherGameTutorial.md)