update multiple approach

Author: mikebarkmin

docs/de/book/multiple-approach-design.md

@@ -18,16 +18,18 @@ Der Nachteil ist, dass das Verhalten der Sprite-Objekte in einer globalen Klasse
 Das heißt, dass mit diesem Ansatz die Einfachheit im Umgang mit Java gegen Kompatibilität mit dem Scratch-Modell getauscht wird.
 
 ```java
+import org.openpatch.scratch.*;
+
 public class MyProgram {
     public MyProgram() {
         Stage myStage = new Stage();
         Sprite zebra = new Sprite();
         zebra.addCostume("walk_1", "assets/walk_1.png");
         zebra.setOnEdgeBounce(true);
 
-        while(true) {
-            zebra.move(1);
-        }
+        zebra.setRun(s -> {
+            s.move(1);
+        })
     }
 }
 ```
@@ -45,6 +47,8 @@ Hier sind ein paar Vergleiche, die man verwenden könnte:
 - In Scratch haben wir Nachrichten zu und von Figure geschickt, indem wir einen Block benutzt haben. In Java definieren wir eigene Methoden und rufen diese dann auf.
 
 ```java
+import org.openpatch.scratch.*;
+
 class Zebra extends Sprite {
     public Zebra() {
         this.addCostume("walk_1", "assets/walk_1.png");
@@ -72,6 +76,8 @@ Der erweiterte Scratch Ansatz basiert auf dem objektorientierten Ansatz, aber f
 Zum Beispiel gibt es in Scratch for Java die Window-Klasse. Welches nur einmalig instanziiert werden kann. Dieses Objekt kann mehrere Bühnen enthalten und zwischen ihnen wechseln. Du kannst auch die Größe des Fensters verändern.
 
 ```java
+import org.openpatch.scratch.*;
+
 public class MyProject extends Window {
     public MyProject() {
         super(800, 600);
@@ -88,6 +94,8 @@ public class MyProject extends Window {
 Eine andere Erweiterung ist die Klasse AnimatedSprite, welches es sehr einfach macht Animation zu verwenden. Die Klasse kann sehr früh verwendet werden, denn sie beseitig den Nachteil, dass Skripte nicht pausiert werden können.
 
 ```java
+import org.openpatch.scratch.extensions.animation.*;
+
 public Zebra extends AnimatedSprite {
     public Zebra() {
         this.addAnimation("walk", "walk_%d.png", 4);

docs/en/book/multiple-approach-design.md

@@ -17,16 +17,18 @@ The downside to this approach is that you define the behavior of the Sprites ins
 So by using this approach you are trading simplicity with compatibility to the Scratch model.
 
 ```java
+import org.openpatch.scratch.*;
+
 public class MyProgram {
     public MyProgram() {
         Stage myStage = new Stage();
         Sprite zebra = new Sprite();
         zebra.addCostume("walk_1", "assets/walk_1.png");
         zebra.setOnEdgeBounce(true);
 
-        while(true) {
-            zebra.move(1);
-        }
+        zebra.setRun(s -> {
+            s.move(1);
+        })
     }
 }
 ```
@@ -44,6 +46,8 @@ Here are a few comparisons you could draw:
 - In Scratch we send messages to and from sprites by using a block. In Java we call methods on an object `mySprite.goLeft()`. A method is similar to a custom block.
 
 ```java
+import org.openpatch.scratch.*;
+
 class Zebra extends Sprite {
     public Zebra() {
         this.addCostume("walk_1", "assets/walk_1.png");
@@ -71,6 +75,8 @@ The enhanced Scratch approach is based on the object-oriented approach, but intr
 For example in Scratch for Java you can create an object from the Window-class. This object can hold multiple stages and can switch between those. You can also define the size of the window - by default it uses the same size as a Scratch project.
 
 ```java
+import org.openpatch.scratch.*;
+
 public class MyProject extends Window {
     public MyProject() {
         super(800, 600);
@@ -87,6 +93,8 @@ public class MyProject extends Window {
 Another enhancement is the class AnimatedSprite, which makes it easy to use an animated for Sprites. This class should be used early since it overcomes the downside of not having a per-sprite wait-block by abstracting the timing.
 
 ```java
+import org.openpatch.scratch.extensions.animation.*;
+
 public Zebra extends AnimatedSprite {
     public Zebra() {
         this.addAnimation("walk", "walk_%d.png", 4);