Initial commit

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB1.java

@@ -0,0 +1,102 @@
+import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+ * Die Klasse Robita ist eine Unterklasse von Roboter.
+ * Sie erbt damit alle Attribute und Methoden der Klasse Roboter.
+ */
+
+public class AB1 extends Roboter
+{
+
+    public void einsVor() {
+        this.verbraucheEnergie(4);
+        super.einsVor();
+    }
+
+    public void dreheRechts() {
+        super.dreheRechts();
+    }
+
+    public void dreheLinks() {
+        super.dreheLinks();
+    }
+
+    public void schraubeAufnehmen() {
+        if (istAufSchraube()) super.aufnehmen();
+    }
+
+    public void schraubeAblegen() {
+        super.ablegen("Schraube");
+    }
+
+    public int getAnzahlSchrauben() {
+        return super.getAnzahl("Schraube");
+    }
+
+    public boolean istAufSchraube() {
+        return super.istAufGegenstand("Schraube");
+    }
+
+    public boolean istVorratLeer() {
+        return super.getAnzahl("Schraube")==0;
+    }
+
+    public void akkuAufnehmen() {
+        if (istAufGegenstand("Akku")) super.aufnehmen();
+    }
+
+    public void benutzeAkku() {
+        if (this.getAnzahl("Akku")>0) benutze("Akku");
+    }
+
+    public void leveltest() {
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+        aufnehmen();
+        einsVor();
+        aufnehmen();
+        benutzeAkku();
+        einsVor();
+        dreheRechts();
+        einsVor();
+        aufnehmen();
+        dreheRechts();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        aufnehmen();
+        benutzeAkku();
+        dreheLinks();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        aufnehmen();
+        dreheRechts();
+        einsVor();
+        dreheRechts();
+        einsVor();
+        aufnehmen();
+        dreheLinks();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB10.java

@@ -0,0 +1,126 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+ * Write a description of class AB10 here.
+ * 
+ * @author (your name) 
+ * @version (a version number or a date)
+ */
+public class AB10 extends AB3
+{
+    /*#
+     * Aufgaben 1, 2 und 3: Patrouille
+     */
+    public void rundeDrehen() {
+        int anzGemacht;
+        anzGemacht = 0;
+        while (anzGemacht < 20) {
+            laufeBisWand();
+            dreheUm();
+            anzGemacht++;
+        }
+        
+        /* Mit for-Schleife:
+           for (int anzGemacht=0; anzGemacht<10; anzGemacht++ ) {
+             laufeBisWand();
+             dreheUm();
+           } // end of for
+        */
+    }
+
+    /*#
+     * Aufgabe 4: Zu Befehl!
+     */
+    public void dreheAnzahlRunden(int anz) {
+        for (int i=0; i<anz*2; i++) {
+            if(getEnergie()<=60 && hatGegenstand("Akku")){
+               benutze("Akku");
+            }
+            laufeBisWand();
+            dreheUm();
+        }
+    }
+
+    /*#
+     * Aufgabe 5: Lauf x Schritte
+     */ 
+    public void geheSchritte(int x) {
+        for(int i=0; i< x; i++) {
+            if(istVorneFrei()) einsVor();
+        }
+    }
+
+
+    /*
+     * Aufgabe 6: Der Roboter läuft anz/2 Mal hin und her und sammelt fleißig ein.
+     */
+    public void sammle(int anz) {
+        for(int i=0; i<anz; i++) {
+            while(!this.istWandVorne()){
+                aufnehmen();
+                einsVor();
+            }
+            dreheUm();
+        }
+    }
+    
+    /**
+     * Hilfsmethode für den Einsatz
+     */
+    public boolean einsVorSammle(){
+        if(istVorneFrei() && this.getEnergie()>5) {
+            einsVor();
+            if(this.istAufGegenstand("Diamant")) 
+            { aufnehmen(); }
+            return true;
+        } else {
+            return false;
+        }
+    }
+    
+
+    /*#
+     * Aufgabe 7: Aufräumen
+     */
+    public void aufraeumen() {
+        for(int i=0; i<8;i++) {
+            einsVor();
+            einsVor();
+            dreheUm();
+        }
+    }
+
+    /*
+     * Hilfsmethode, die den Aufzug holt.
+     */ 
+    public void holeAufzug() {
+        if(!istVorne("Schalter")) {
+            dreheUm();
+        }
+        benutze("Schalter");
+    }
+
+    /*#
+     * Aufgabe 8: Aufzug
+     */
+    public void fahreAufzug(int etagen, boolean abwaerts) {
+        if(abwaerts) {
+            while(getRotation()!=90) dreheRechts();
+        } else {
+            while(getRotation()!=270) dreheRechts();
+        }
+        for(int i=0; i< etagen; i++) einsVor();
+    }
+    
+    public void fahreInsStockwerk(int etage) {
+        if(etage > getY()) {
+            while(getRotation()!=90) dreheRechts();
+        } else {
+            while(getRotation()!=270) dreheRechts();
+        }
+        int etagen = Math.abs(getY()-etage);            
+        for(int i=0; i< etagen; i++) einsVor();
+    }
+
+
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB2.java

@@ -0,0 +1,94 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+public class AB2 extends Roboter
+{
+    /*#
+     * Aufgabe 3: Diese Anweisungen stimmen noch nicht wirklich
+     * Verbessere und Ergaenze.
+     */
+    public void dreheRunde() 
+    {
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+    }
+
+    /*#
+     * Aufgabe 4: Drehe um
+     */
+    public void dreheUm() 
+    {
+        // Hier kommen die Befehl für eine 180° Drehung hin
+        dreheRechts();
+        dreheRechts();
+    }
+
+    /*#
+     * Aufgabe 5: Sammle Schrauben
+     */
+    public void sammle3() 
+    {
+        einsVor();
+        aufnehmen();
+        einsVor();
+        aufnehmen();
+        einsVor();
+        aufnehmen();
+    }
+
+    /*#
+     * Aufgabe 6: Haken schlagen
+     * Hier ist Platz fuer deine erste eigens geschriebene Methode!
+     */
+    public void hakenSchlagen() {
+        dreheLinks();
+        einsVor();
+        dreheRechts();
+        einsVor();
+        einsVor();
+        dreheRechts();
+        einsVor();
+        dreheLinks();
+    }
+
+    /*#
+     * Aufgabe 7: Vier Dinge sammeln
+     */
+    public void vierSammeln() {
+        sammle3();
+        einsVor();
+        aufnehmen();
+    }
+
+    /*#
+     * Einsatz 2: Bitte den Namen nicht aendern!
+     */
+    public void einsatz2() {
+        // Hier kommte der Code für den ersten echten Einsatz hin
+        einsVor();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        einsVor();
+        aufnehmen();
+        hakenSchlagen();
+        sammle3();
+        einsVor();
+        dreheRechts();
+        einsVor();
+        einsVor();
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB3.java

@@ -0,0 +1,130 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+public class AB3 extends Roboter
+{
+
+    /*#
+     * Aufgabe 1: Feuer loeschen
+     */
+    public void loesche() {
+        einsVor();
+        aufnehmen();
+        vorBisFeuer();
+        loescheReihe();
+
+    }
+
+    /*#
+     * Aufgaben 3 & 4: Vor bis zum Feuer (wo auch immer das ist)
+     */
+    public void vorBisFeuer() 
+    {
+        while(!istVorne("Feuer")) {
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 5: Feuersbrunst loeschen
+     */
+    public void loescheReihe() {
+        while(istVorne("Feuer")) {
+            benutze("Feuerloescher");
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 6: Teste Reichweite eines Feuerloeschers
+     */
+    public void testReichweite() {
+        einsVor();
+        dreheLinks();
+        einsVor();
+        aufnehmen();
+        dreheUm();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        while(getAnzahl("Feuerloescher")>=1) {
+            benutze("Feuerloescher");
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 7: Feuerloescher einsammeln
+     */
+    public void sammleLoescher() 
+    {
+        while(istVorneFrei()) {
+            einsVor();
+            dreheLinks();
+            einsVor();
+            aufnehmen();
+            dreheUm();
+            einsVor();
+            dreheLinks();
+            einsVor();
+        }
+    }  
+
+    /*#
+     * Hilfsmethode fuer Aufgabe 8
+     */
+    public void laufeBisWand() {
+        while(istVorneFrei()) {
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 8: Homerun
+     */
+    public void laufeBisSackgasse() {
+        laufeBisWand();
+        while(!istWandLinks()) {
+            dreheLinks();
+            laufeBisWand();
+        }
+    }
+
+    /*#
+     * Einsatz 3: Bitte den Namen nicht aendern!
+     */
+    public void einsatz3() {
+         sammleLoescher();
+         dreheRechts();
+         einsVor();
+
+        while(!istAufGegenstand("Portal")) {
+            benutze("Akku");
+            einsVor();
+            dreheRechts();
+            vorBisFeuer();
+            loescheReihe();
+            dreheUm();
+            laufeBisWand();
+            dreheRechts();
+        }
+        
+        
+        /* Alternativ: ohne unnötige Wege 
+         * ------------------------------
+         while(!istAufGegenstand("Portal")) {
+            benutze("Akku");
+            einsVor();
+            dreheRechts();
+            vorBisFeuer();
+            loescheReihe();
+            dreheLinks();
+            benutze("Feuerloescher");
+            einsVor();
+            dreheLinks();
+            loescheReihe();
+            laufeBisWand();
+            dreheRechts();
+          }
+        */
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB4.java

@@ -0,0 +1,133 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+ * Write a description of class AB4 here.
+ * 
+ * @author (your name) 
+ * @version (a version number or a date)
+ */
+public class AB4 extends Roboter
+{
+    /*#
+     * Aufgabe 1: Spur invertieren
+     */
+    /** 
+     * Der Roboter tauscht aus. Wo eine Scharube liegt, hebt er sie auf.
+     * Wo keine liegt, legt er eine ab, wenn er noch Schrauben 
+     * in seinem Vorrat hat.
+     */
+    public void tausche() {
+        if (istAufGegenstand("Schraube")) { 
+            aufnehmen();
+        } 
+        else {
+            ablegen("Schraube");
+        }
+    }
+
+    /** 
+     * Der Roboter macht mehrere Dinge. Beschreibe in diesem Kommentar:
+     * 
+     */
+    public void tauscheUndVor() {
+        tausche();
+        if (istVorneFrei()) { 
+            einsVor();
+        }
+        // else ist nicht noetig, weil in dem Fall nichts gemacht wird!                 
+    }
+
+    /*#
+     * Aufgabe 2: Tausche die Schraubenreihe bis zur Wand
+     */
+    public void tauscheBisWand() {
+        while (!istWandVorne()){
+            tauscheUndVor();
+        }
+        tausche();
+    }
+
+    /*#
+     * Aufgabe 3: Fleckenfrei
+     */
+    public void umgeheOelfleck() {
+        while (!istWandVorne()){
+            if(istVorne("Oelfleck")) {
+                dreheLinks();
+                einsVor();
+                dreheRechts();
+                einsVor();
+                einsVor();
+                dreheRechts();
+                einsVor();
+                dreheLinks();
+            }
+            else {
+                einsVor();
+            }
+        }
+    }
+
+    /*#
+     * Aufgabe 4: Schluessel aufheben
+     */
+    public void sammleSchluessel() {
+        if (istAufGegenstand("Schluessel")) aufnehmen();
+    }
+
+    /*#
+     * Aufgabe 5: Sesam oeffne dich
+     */
+    public void oeffneTuer(){
+        dreheLinks();
+        if (istVorne("Schloss")) benutze("Schluessel");
+        if (istVorne("Schalter")) benutze("Schalter");
+        dreheRechts();
+    }
+
+    /*#
+     * Hilfsmethode fuer Aufgabe 9
+     */
+    public void laufeBisWand() {
+        while(istVorneFrei()) {
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 9: Labyrinth
+     */
+    public void labyrinth() {
+        while(!(istWandVorne() && istWandLinks() && istWandRechts())) {
+            laufeBisWand();
+            if(!istWandLinks()) {
+                dreheLinks();
+            } else {
+                if(!istWandRechts()) {
+                    dreheRechts();
+                }
+            }
+        }
+    }
+
+    /*#
+     * Einsatz 4: Bitte den Namen nicht aendern!
+     */
+    public void einsatz4() {
+        labyrinth();
+        oeffneTuer();
+        labyrinth();
+        oeffneTuer();
+        labyrinth();
+        oeffneTuer();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        while(istVorneFrei()) {
+            einsVor();
+            dreheLinks();
+            if (istVorne("Schalter")) benutze("Schalter");
+            dreheRechts();
+        }
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB5.java

@@ -0,0 +1,206 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+ * Write a description of class AB5 here.
+ * 
+ * @author (your name) 
+ * @version (a version number or a date)
+ */
+public class AB5 extends Roboter
+{
+    /*#
+     * Aufgabe 1, 2, 3 und 10: Upgrade 1 - ein neuer Sensor wird erstellt
+     */
+    public boolean istFassVorne() {
+        // Aufgabe 3a
+
+        if (istVorne("Fass") || istVorne("Atommuell")) {
+            // Aufgabe 3b
+
+            return true;
+        } else {
+            // Aufgabe 3b
+
+            return false;
+        }
+        // Aufgabe 3c
+
+    }
+
+    /*#
+     * Aufgabe 4: Rueckspiegel
+     */
+    private boolean istFassHinten() {
+        dreheUm();
+        if (istVorne("Fass")) {
+            dreheUm();
+            return true;
+        }else {
+            dreheUm();
+            einsVor();
+            return false;
+        }
+
+    }
+
+    /*#
+     * Aufgabe 5: Out of Power
+     */
+    public boolean istEnergieSchwach() {
+        if (getEnergie()<40) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /*#
+     * Aufgabe 6: Heavy Duty
+     */
+    public boolean istSchwerBeladen() {
+        if (getAnzahl() >= 5) {
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    /*#
+     * Aufgabe 7 und 11: Look Ahead - Upgrade 2
+     */
+    public boolean istVorFassFrei() {
+        if (istEnergieSchwach() && getAnzahl("Akku")>0) {
+            benutze("Akku");
+        }
+
+        dreheRechts();
+        einsVor();
+        dreheLinks();
+        einsVor();
+        if (istWandVorne()) {
+            dreheUm();
+            einsVor();
+            dreheRechts();
+            einsVor();
+            dreheRechts();
+            return false;
+        } else {
+            einsVor();
+            dreheLinks();
+            if (istWandVorne() || istFassVorne()) {
+                dreheLinks();
+                einsVor();
+                einsVor();
+                dreheRechts();
+                einsVor();
+                dreheRechts();
+                return false;
+            } else {
+                dreheLinks();
+                einsVor();
+                einsVor();
+                dreheRechts();
+                einsVor();
+                dreheRechts();
+                return true;
+            }
+        }
+    }
+
+    /*#
+     * Aufgabe 8: Aufraeumen
+     */
+    public void schiebeFassBisWand() {
+        while (istVorFassFrei()) {
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 9: Fuehrerschein
+     */
+    public boolean istKreuzung() {
+        if (!(istWandVorne()) && !(istWandLinks()) && !(istWandRechts())) {
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    public void geheBisKreuzung() {
+        while(!istKreuzung()) {
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 12: Wie koennte man diese Methode nennen?
+     */
+    public void schiebeEcke() {
+        schiebeFassBisWand();
+        dreheLinks();
+        einsVor();
+        dreheRechts();
+        einsVor();
+        dreheRechts();
+        schiebeFassBisWand();
+    }
+
+    /*#
+     * Einsatz 5: Bitte den Namen nicht aendern!
+     */
+    public void einsatz5() {
+        geheBisKreuzung();
+        einsVor();
+        while (!istWandVorne()) {
+            aufnehmen();
+            einsVor();
+        }
+        aufnehmen();
+        dreheUm();
+        geheBisKreuzung();
+        dreheRechts();
+        while(!istWandVorne()) {
+            einsVor();
+            dreheRechts();
+            if (istFassVorne()) {
+                schiebeFassBisWand();
+                dreheUm();
+                laufeBisWand();
+                dreheRechts();
+            } else {
+                dreheLinks();
+            }
+        }
+        dreheLinks();
+        dreheLinks();
+        geheBisKreuzung();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        einsVor();
+        dreheLinks();
+        while (!istFassVorne()) {
+            einsVor();
+        }
+        schiebeEcke();
+        dreheUm();
+        laufeBisWand();
+        dreheLinks();
+        laufeBisWand();
+        dreheRechts();
+        einsVor();
+        dreheRechts();
+        while (!istFassVorne()) {
+            einsVor();
+        }
+        schiebeEcke();
+    }
+
+    public void laufeBisWand() {
+        while(!istWandVorne()) {
+            einsVor();
+        }
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB6.java

@@ -0,0 +1,246 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+ * Write a description of class AB6 here.
+ * 
+ * @author (your name) 
+ * @version (a version number or a date)
+ */
+public class AB6 extends Roboter
+{  
+    // Eigenschaften eines AB6 - Objektvariablen (Attribute) werden deklariert:
+    private int schritte;
+    // Aufgabe 8: Hier wird das Attribut drehungen deklariert:
+
+    private int brennstaebe;
+
+    /*#
+     * Konstruktor eines AB6: Der Startzustand wird definiert
+     */
+    public AB6() {
+        // Startzustand eines AB6 - Objektvariablen werden initialiaiert:
+        this.schritte = 0;
+        // Aufgabe 8: Initialisiere das Attribut drehungen hier:
+
+        this.brennstaebe = 0;
+    }
+
+    /*#
+     * AB7 - Aufgabe 4: Super
+     */
+    public void einsVorMitZaehlen() {
+        // Das Attribut Schritte wird um eins erhoeht: 
+        this.schritte++;
+        super.einsVor();
+    }
+
+    /*#
+     * Aufgabe 7: Schrittezaehler
+     * AB7 - Aufgabe 5: Brennstaebe zaehlen
+     */
+    public void bisWandMitZaehlen() {
+
+    }
+
+    /*#
+     * Aufgabe 8: Drehzaehler
+     * AB7 - Aufgabe 6:
+     */
+    public void dreheRechtsMitZaehlen() {
+
+    }
+
+    public void dreheLinksMitZaehlen() {
+
+    }
+
+    /*#
+     * Aufgabe 9: Eine get-Methode
+     */
+    public int getSchritte() {
+        return 0;
+    }
+
+    /*#
+     * Aufgabe 10: Deine get-Methode
+     */
+    // Hier kommt deine get-Methode fuer die Anzahl der Drehungen hin.
+    // Benenne sie sinnvoll:
+
+    /*#
+     * Methoden fuer den Einsatz 6
+     */
+    public boolean istFassLinks() {
+        // Kopiere dir den Methodeninhalt aus AB5 und entferne das return true;
+        return true;
+    }
+
+    public boolean istWandLinks() {
+        // Kopiere dir den Methodeninhalt aus AB5 und entferne das return true;
+        return true;
+    }
+    
+    /*#
+     * Einsatz 6:
+     */
+    public void einsatz6() {
+
+    }
+
+    /*#
+     * Weitere Methoden zum Arbeitsblatt 7:
+     */
+
+    /*#
+     * AB7 - Aufgabe 1: Kreuzungen zaehlen
+     */
+    
+    /*#
+     * AB7 - Aufgabe 6: Standardmethoden ueberschreiten 
+     */
+
+    /*#
+     * AB7 - Aufgabe 7: Fass links
+     */
+    // Hier kommt die Methode istFassLinks() hin:
+
+    /*#
+     * AB7 - Aufgabe 8: Ueberschreiben
+     */
+    public boolean wandVorne() {
+        // Entferne das return true;
+        return true;
+    }
+
+    public boolean fassLinks() {
+        // Entferne das return true;
+        return true;
+    }
+
+    public boolean wandLinks() {
+        // Entferne das return true;
+        return true;
+    }
+    
+    /*#
+     * Einsatz 7:
+     */
+    public void einsatz7(){
+
+    }
+
+    /*#
+     * Methoden fuer deinen Lehrer:
+     */
+    public int getBrennstaebe() {
+        return brennstaebe;
+    }
+
+    /*#
+     * Loesungen:
+     */
+    // private int schritte;
+    // private int drehungen;
+    // private int brennstaebe;
+
+    // public AB6() {
+    // this.schritte = 0;
+    // this.drehungen = 0;
+    // this.brennstaebe = 0;
+    // }
+
+    // public void einsVor() {
+    // this.schritte++;
+    // super.einsVor();
+    // }
+
+    // public void dreheRechtsMitZaehlen() {
+    // this.drehungen++;
+    // dreheRechts();
+    // }
+
+    // public void dreheLinksMitZaehlen() {
+    // this.drehungen--;
+    // dreheLinks();
+    // }
+
+    // public void bisWandMitZaehlen() {
+    // while(!this.istWandVorne()) {
+    // einsVor();
+    // if(istAufGegenstand("Brennstab")) {
+    // this.brennstaebe++;
+    // }
+    // }
+
+    // }
+
+    // public int getSchritte() {
+    // return this.schritte;
+    // }
+
+    // public boolean istWandVorne() {
+    // if (super.istWandVorne() || this.istFassVorne()) {
+    // return true;
+    // } else {
+    // return false;
+    // }
+    // }
+
+    // public boolean istFassLinks() {
+    // dreheLinks();
+    // if (istFassVorne()) {
+    // dreheRechts();
+    // return true;
+    // } else {
+    // dreheRechts();
+    // return false;
+    // }
+    // }
+
+    // public boolean istWandLinks() {
+    // if (super.istWandLinks() || istFassLinks()) {
+    // return true;
+    // } else {
+    // return false;
+    // }
+    // }
+
+    // public void einsatz6() {
+    // bisWandMitZaehlen();
+    // dreheRechtsMitZaehlen();
+    // while(!this.istAufGegenstand("Portal")) {
+    // if (!this.istWandLinks() && drehungen!=0) {
+    // dreheLinksMitZaehlen();
+    // } else {
+    // while(this.istWandVorne()) {
+    // dreheRechtsMitZaehlen();
+    // }
+    // }
+    // einsVor();
+    // }
+    // }
+
+    // public void einsatz7(){
+    // einsVor();
+    // this.brennstaebe = 0;
+    // while(!istWandVorne()) {
+    // if(istKreuzung()) {
+    // dreheRechts();
+    // bisWandMitZaehlen();
+    // dreheUm();
+    // einsVor();
+    // geheBisKreuzung();
+    // bisWandMitZaehlen();
+    // dreheUm();
+    // einsVor();
+    // geheBisKreuzung();
+    // dreheLinks();
+    // }
+    // einsVor();
+    // }
+    // aufnehmen();
+    // benutze("Akku");
+    // einsatz5();
+
+    // }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB6_AB7.java

@@ -0,0 +1,178 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+/**
+ * Write a description of class AB6 here.
+ * 
+ * @author (your name) 
+ * @version (a version number or a date)
+ */
+public class AB6_AB7 extends AB5
+{  
+    // Eigenschaften eines AB6 und AB7 - Objektvariablen (Attribute) werden deklariert:
+    private int schritte;
+    // Aufgabe 8: Hier wird das Attribut drehungen deklariert:
+    private int drehungen;
+
+    private int brennstaebe;
+
+    /*#
+     * Konstruktor eines AB6 und AB7: Der Startzustand wird definiert
+     */
+    public AB6_AB7() {
+        // Startzustand eines AB6 - Objektvariablen werden initialiaiert:
+        this.schritte = 0;
+        // Aufgabe 8: Initialisiere das Attribut drehungen hier:
+        this.drehungen = 0;
+        this.brennstaebe = 0;
+    }
+
+    /*#
+     * AB7 - Aufgabe 4: Super
+     */
+    public void einsVor() {
+        // Das Attribut Schritte wird um eins erhoeht: 
+        this.schritte++;
+        super.einsVor();
+    }
+
+    /*#
+     * AB6 - Aufgabe 7: Schrittezaehler
+     * AB7 - Aufgabe 5: Brennstaebe zaehlen
+     */
+    public void bisWandMitZaehlen() {
+        while(!this.istWandVorne()) {
+            einsVor();
+            if(istAufGegenstand("Brennstab")) {
+                this.brennstaebe++;
+            }
+        }
+    }
+
+    /*#
+     * AB6 - Aufgabe 8: Drehzaehler
+     * AB7 - Aufgabe 6:
+     */
+    public void dreheRechtsMitZaehlen() {
+        this.drehungen++;
+        dreheRechts();
+    }
+
+    public void dreheLinksMitZaehlen() {
+        this.drehungen--;
+        dreheLinks();
+    }
+
+    /*#
+     * AB6 - Aufgabe 9: Eine get-Methode
+     */
+    public int getSchritte() {
+        return this.schritte;
+    }
+
+    /*#
+     * AB6 - Aufgabe 10: Deine get-Methode
+     */
+    // Hier kommt deine get-Methode fuer die Anzahl der Drehungen hin.
+    // Benenne sie sinnvoll:
+
+    /*#
+     * AB6 - Methoden fuer den Einsatz 6
+     */
+    public boolean istFassLinks() {
+        dreheLinks();
+        if (istFassVorne()) {
+            dreheRechts();
+            return true;
+        } else {
+            dreheRechts();
+            return false;
+        }
+    }
+
+    public boolean istWandLinks() {
+        if (super.istWandLinks() || istFassLinks()) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /*#
+     * Einsatz 6:
+     */
+    public void einsatz6() {
+        bisWandMitZaehlen();
+        dreheRechtsMitZaehlen();
+        while(!this.istAufGegenstand("Portal")) {
+            if (!this.istWandLinks() && drehungen!=0) {
+                dreheLinksMitZaehlen();
+            } else {
+                while(this.istWandVorne()) {
+                    dreheRechtsMitZaehlen();
+                }
+            }
+            einsVor();
+        }
+    }
+
+    /*#
+     * Weitere Methoden zum AB 7:
+     */
+
+    /*#
+     * AB7 - Aufgabe 1: Kreuzungen zaehlen
+     */
+
+    /*#
+     * AB7 - Aufgabe 6: Standardmethoden ueberschreiten 
+     */
+
+    /*#
+     * AB7 - Aufgabe 7: Fass links
+     */
+    // Hier kommt die Methode istFassLinks() hin:
+
+    /*#
+     * AB7 - Aufgabe 8: Ueberschreiben
+     */
+    public boolean istWandVorne() {
+        if (super.istWandVorne() || this.istFassVorne()) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /*#
+     * AB7 - Einsatz 7:
+     */
+    public void einsatz7(){
+        einsVor();
+        this.brennstaebe = 0;
+        while(!istWandVorne()) {
+            if(istKreuzung()) {
+                dreheRechts();
+                bisWandMitZaehlen();
+                dreheUm();
+                einsVor();
+                geheBisKreuzung();
+                bisWandMitZaehlen();
+                dreheUm();
+                einsVor();
+                geheBisKreuzung();
+                dreheLinks();
+            }
+            einsVor();
+        }
+        aufnehmen();
+        benutze("Akku");
+        einsatz6();
+    }
+
+    /*#
+     * Methoden fuer deinen Lehrer:
+     */
+    public int getBrennstaebe() {
+        return brennstaebe;
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB8.java

@@ -0,0 +1,203 @@
+import greenfoot.*;
+
+/**
+ * Write a description of class AB8 here.
+ * 
+ * @author (your name) 
+ * @version (a version number or a date)
+ */
+public class AB8 extends AB5
+{
+    private int zaehler1;
+    private double wert;
+
+    public AB8() {
+        this.zaehler1 = 0;
+        this.wert = 0.0;
+    }
+
+    /*#
+     * Aufgabe 1: Zwei Methoden, die fast das gleiche machen ...
+     */
+    public int zaehleSchritteBisWand1() {
+        while(!istWandVorne()) {
+            this.zaehler1++;
+            einsVor();
+        }
+        return this.zaehler1;
+    }
+
+    public int zaehleSchritteBisWand2() {
+        int zaehler2;
+        zaehler2 = 0;
+        while(!istWandVorne()){
+            zaehler2++;
+            einsVor();
+        }
+        return zaehler2;
+    }
+
+    /*#
+     * Aufgabe 4: Summe der x- und y-Koordinate
+     */
+    public int gibPositionssumme() {
+        int x;
+        int y;
+        int summe;
+        x = getX();
+        y = getY();
+        summe = x + y;
+        return summe;
+    }
+
+    /*#
+     * Aufgabe 5: Abstabdsberechnungen
+     */
+    public int gibLaenge() {
+        int x1;
+        int x2;
+        int x_diff;
+        int y1;
+        int y2;
+        int y_diff;
+        int laenge;
+        x1 = getX();
+        y1 = getY();
+        laufeBisWand();
+        x2 = getX();
+        y2 = getY();
+        x_diff = x2-x1;
+        if (x_diff<0) {
+            x_diff = -x_diff;
+        }
+        y_diff = y2-y1;
+        if (y_diff<0) {
+            y_diff=-y_diff;
+        }    
+        if (x_diff==0) {
+            laenge = y_diff+1;
+        }
+        else {
+            laenge = x_diff+1;
+        }
+        return laenge;
+    }
+
+    /*#
+     * Aufgabe 6: Flaeche
+     */
+    public int gibRaumgroesse() {
+        int breite;
+        int hoehe;
+        int groesse;
+        breite = gibLaenge();
+        dreheRechts();
+        hoehe = gibLaenge();
+        groesse = breite * hoehe;
+        return groesse;
+    }
+
+    /*#
+     * Aufgabe 7: 
+     */
+    public boolean istFassRechts() {
+        dreheRechts();
+        if (istVorne("Fass")) {
+            dreheLinks();
+            return true;
+        }else {
+            dreheLinks();
+            return false;
+        }
+    }
+
+    public int gibLaengeFassReihe() {
+        int laenge;
+        laenge = 0;
+        while(istFassRechts()) {
+            laenge++;
+            einsVor();
+        }
+        return laenge;
+    }
+
+    public int gibAnzahlFaesser() {
+        int breite;
+        int hoehe;
+        int groesse;
+        einsVor();
+        breite = gibLaengeFassReihe();
+        dreheRechts();
+        einsVor();
+        hoehe = gibLaengeFassReihe();
+        groesse = breite*hoehe;
+        return groesse;
+    }
+
+    /*#
+     * Aufgabe 9: Sammler
+     */
+    public void sammeln() {
+        while(!istWandVorne()) {
+            einsVor();
+            if (istAufGegenstand("Schraube")) {
+                this.wert = this.wert+0.20;
+                aufnehmen();
+            }
+            if (istAufGegenstand("Akku")) {
+                this.wert = this.wert+2.40;
+                aufnehmen();
+            }
+            if (istAufGegenstand("Schluessel")) {
+                this.wert = this.wert+5.00;
+                aufnehmen();
+            }
+            if (istAufGegenstand("Feuerloescher")) {
+                this.wert = this.wert+40.00;
+                aufnehmen();
+            }
+        }
+    }
+
+    // Hier muss noch eine get-Methode hin:
+    public double getWert() {
+        return this.wert;
+    }
+
+    /*#
+     * Aufgabe 10: Finanzamt
+     */
+    public double gibMehrwertSteuer() {
+        double steuer;
+        steuer = this.wert * 0.19;
+        return steuer;
+    }
+
+    /*#
+     * Einsatz 8: Den Namen bitte nicht aendern!
+     */
+    public int einsatz8() {
+        int g;
+        g = 0;
+        while(!istWandVorne()) {
+            if (!istWandRechts()) {
+                dreheRechts();
+
+                einsVor();
+                einsVor();
+                einsVor();
+                einsVor();
+                dreheLinks();
+                g = g + gibRaumgroesse();
+                dreheRechts();
+                laufeBisWand();
+                dreheRechts();
+                laufeBisWand();
+                dreheRechts();
+            }
+            einsVor();
+        }
+
+        return g-1;
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/AB9.java

@@ -0,0 +1,112 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+
+public class AB9 extends Roboter
+{
+
+    /**
+     * Hilfesmethode zum Holen des Aufzugs. 
+     */
+    public void holeAufzug() {
+        if(!istVorne("Schalter")) {
+            dreheUm();
+        }
+        benutze("Schalter");
+    }
+
+    /*#
+     * Aufgabe 3: Drehe Roboter
+     */
+
+    public void dreheRoboter(int richtung) {
+        while(getRotation() != richtung) { // Solange die die Richtung des Roboters nicht die geforderte Richtung ist
+            dreheRechts();                 // drehe nach rechts
+        }
+    }
+
+    /*#
+     * Aufgabe 4: Laufe zu X-Position
+     */
+    public void laufeZuXPos(int x) {
+        if(x < getX()) {         // Drehe in richtige Richtung
+            dreheRoboter(180);
+        } else {
+            dreheRoboter(0);
+        }
+        while(x != getX()) {     // Laufe solange die x-Koordinate noch nicht stimmt
+            einsVor();
+        }
+    }
+
+    /*#
+     * Aufgabe 5: Fahre Aufzug
+     */
+    public void fahreAufzug(int etagen, boolean abwaerts) {
+        if (istAufGegenstand("Aufzug")) {
+            if(abwaerts) {
+                dreheRoboter(90);
+            } else {
+                dreheRoboter(270);
+            }
+
+            while(etagen>0 && istVorneFrei()) {
+                einsVor();
+                etagen--;
+            }
+        }
+    }
+
+    /*#
+     * Aufgabe 6: Fahre ins Stockwerk
+     */
+    public void fahreInsStockwerk(int etage) {
+        if(getY() < etage) {        // Nach unten fahren?
+            dreheRoboter(90);
+        }else {
+            dreheRoboter(270);
+        }
+        while(getY() != etage && istVorneFrei()) {     // Fahre bis zur richtigen Etage
+            einsVor();
+        }
+    }
+
+    /*#
+     * Bombe sichern:
+     */
+    public void holeBombeUndKehreZurueck (int xBombe, int yBombe){
+        while (!istAufGegenstand("Aufzug")) {
+            einsVor();
+        }
+        fahreInsStockwerk(yBombe);
+        int x = getX();
+        laufeZuXPos(xBombe);
+        aufnehmen();
+        laufeZuXPos(x);
+    }
+    
+    /*#
+     * Aufgabe 8: Sprengen
+     */
+    public void sprenge(int x, int y) {
+        fahreInsStockwerk(y);
+        laufeZuXPos(x);
+        benutze("Bombe");
+    }
+    
+    /*#
+     * Aufgabe 9: Stollen fuellen ... 
+     * Hier darfst du mal ganz alleine eine Methode mit Parametern implementieren ;-)
+     */
+   
+    public void legeZweierreihe(int breite) {
+        while(breite>0){
+            ablegen("Brennstab");
+            einsVor();
+            ablegen("Brennstab");
+            breite--;
+        }
+    }
+    /*#
+     * Platz fuer weitere Methode(n), die du eventuell fuer den Einsatz 9 benoetigst:
+     */
+
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/Aufzugknopf.java

@@ -0,0 +1,58 @@
+import greenfoot.*;
+import java.util.List;
+
+/**
+ * Spezieller Schalter zum Rufen eins Aufzugs.
+ * 
+ * @author Thomas Schaller
+ * @version 28.06.2017 V1.0
+ */
+public class Aufzugknopf extends Schalter 
+{
+    Gegenstand aufzug;
+    int stockwerk;
+
+    /**
+     * Konstruktor Aufzugknopf
+     */
+    public Aufzugknopf(World w)
+    {
+        super(w);
+        aufzug = null;
+    }
+
+    /**
+     * Setzt den dazugehörigen Aufzug
+     * 
+     * @param  aufzug   Ein Gegenstand vom Typ Aufzug
+     */
+    public void setAufzug(Gegenstand aufzug, int stockwerk)
+    {
+        this.aufzug = aufzug;
+        this.stockwerk = stockwerk;
+    }
+
+    public void rufeAufzug() {
+        List<Actor> beiAufzug = aufzug.getWorld().getObjectsAt(aufzug.getX(), aufzug.getY(), Actor.class);
+        while(aufzug.getY() != stockwerk) {
+            int neuy =aufzug.getY()-(aufzug.getY()-stockwerk)/Math.abs(aufzug.getY()-stockwerk);
+            for(Actor a : beiAufzug) {    
+                if(a != aufzug)           
+                a.setLocation(aufzug.getX(), neuy);
+            }
+            aufzug.setLocation(aufzug.getX(), neuy);
+            Greenfoot.delay(1);
+        }
+    }
+
+    /** Schaltet den Schalter um, d.h. von on auf off oder umgekehrt
+     */
+    public void umschalten() {
+        anschalten();
+        Greenfoot.delay(1);
+        rufeAufzug();
+        ausschalten();
+        Greenfoot.delay(1);
+    }
+
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/EinsatzLeiter.java

@@ -0,0 +1,207 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.util.List;
+
+public class EinsatzLeiter extends Actor
+{
+    // Hier werden alle Roboter aufgelistet, denen der Einsatzleiter Befehle erteilen kann:
+    AB9 legeRoboter; //Legeroboter
+    AB9 sprengRoboter1; //Sprengroboter 1
+    AB9 sprengRoboter2; //Sprengroboter 2
+    AB9 aufzugRoboter; //Aufzugroboter
+    
+    // Roboter für Einsatz 10
+    AB10 roboter1;
+    AB10 roboter2;
+    AB10 roboter3;
+
+    /*#
+     * Aufgabe 10: Anweisung 1
+     * Hier werden Methoden am sprengRoboter1 aufgerufen.
+     * Tipp: Schreibe sprengRoboter1. und druecke STRG+Leertaste --> Schau mal, welche Methoden du alle zur Verfuegung hast ...
+     */
+    public void holeBombeUndSprenge (int bx, int by, int sx, int sy){
+        // Hinweis:
+        // Der sprengRoboter1 bekommt den Befehl holeBombeUndKehreZurueck(bx, by), wenn du vorher beim AB9-Roboter programmiert hast.
+        // (bx|by) sind die Koordinaten der Bombe --> das muss dann der Methodenaufrufer eingeben (also du spaeter, 
+        // wenn du am EinsatzLeiter diese Methode aufrufst): sprengRoboter1.holeBombeUndKehreZurueck(bx, by);
+        // Gib dem sprengRoboter1 den Befehl zum Sprengen an der Position (sx,sy):
+        // Kombiniere nun die richtigen Methodenaufrufe beim Aufzug- und Sprengroboter.
+        aufzugRoboter.holeAufzug();
+        sprengRoboter1.holeBombeUndKehreZurueck(bx,by);
+        sprengRoboter1.sprenge(sx,sy);        
+    }
+
+ 
+
+    /*#
+     * Ab hier kannst du Hilfs-Methoden fuer den Einsatz 9+10 implementieren:
+     */
+
+    /*#
+     * Einsatz 9:
+     */
+    public void einsatz9() {
+        aufzugRoboter.holeAufzug();
+        sprengRoboter1.holeBombeUndKehreZurueck(2,4);
+        sprengRoboter1.sprenge(9,5);
+        sprengRoboter1.dreheUm();
+        sprengRoboter1.holeBombeUndKehreZurueck(3,4);
+        sprengRoboter1.sprenge(3,8);
+        sprengRoboter1.dreheUm();
+        sprengRoboter1.einsVor();
+        sprengRoboter1.fahreInsStockwerk(4);
+        sprengRoboter1.dreheLinks();
+        sprengRoboter1.einsVor();
+        sprengRoboter1.einsVor();
+        sprengRoboter1.einsVor();
+        sprengRoboter1.einsVor();
+        sprengRoboter1.dreheUm();
+        aufzugRoboter.holeAufzug();
+        sprengRoboter2.holeBombeUndKehreZurueck(4,4);
+        sprengRoboter2.dreheUm();
+        sprengRoboter2.einsVor();
+        sprengRoboter2.aufnehmen();
+        sprengRoboter2.dreheUm();
+        sprengRoboter2.einsVor();
+        sprengRoboter2.sprenge(11,9);
+        sprengRoboter2.benutze("Bombe");
+        sprengRoboter2.dreheUm();
+        sprengRoboter2.einsVor();
+        sprengRoboter2.fahreInsStockwerk(4);
+        sprengRoboter2.dreheLinks();
+        sprengRoboter2.einsVor();
+        aufzugRoboter.holeAufzug();
+        while(!legeRoboter.istAufGegenstand("Aufzug"))legeRoboter.einsVor();
+        legeRoboter.fahreInsStockwerk(5);
+        legeRoboter.dreheLinks();
+
+        legeRoboter.einsVor();
+        legeRoboter.legeZweierreihe(3);
+        legeRoboter.dreheUm();
+        while(!legeRoboter.istAufGegenstand("Aufzug"))legeRoboter.einsVor();
+        legeRoboter.fahreInsStockwerk(8);
+        legeRoboter.dreheRechts();
+        legeRoboter.einsVor();
+        legeRoboter.benutze("Akku");
+        legeRoboter.benutze("Akku");
+       
+           legeRoboter.legeZweierreihe(3);
+       
+        legeRoboter.dreheUm();
+        while(!legeRoboter.istAufGegenstand("Aufzug"))legeRoboter.einsVor();
+        legeRoboter.fahreInsStockwerk(9);
+        legeRoboter.dreheLinks();
+        legeRoboter.einsVor();
+        legeRoboter.benutze("Akku");
+        legeRoboter.benutze("Akku");
+        legeRoboter.legeZweierreihe(5);
+        legeRoboter.dreheUm();
+        while(!legeRoboter.istAufGegenstand("Aufzug"))legeRoboter.einsVor();
+        legeRoboter.benutze("Akku");
+        legeRoboter.fahreInsStockwerk(2);
+        legeRoboter.dreheRechts();
+        legeRoboter.einsVor();
+        legeRoboter.einsVor();
+        
+        sprengRoboter1.holeAufzug();
+        sprengRoboter2.dreheUm();
+        sprengRoboter2.einsVor();
+        aufzugRoboter.holeAufzug();
+        sprengRoboter2.einsVor();
+        sprengRoboter1.holeAufzug();
+        sprengRoboter1.dreheUm();
+        while(!sprengRoboter1.istAufGegenstand("Aufzug"))sprengRoboter1.einsVor();
+        aufzugRoboter.holeAufzug();
+
+      
+    }
+    /*#
+     * Einsatz 10:
+     */
+
+    public void einsatz10() {
+        roboter1.holeAufzug();
+        AB10 r = roboter3;
+        r.laufeBisWand();
+        r.fahreAufzug(4,true);
+        r.dreheLinks();
+        r.geheSchritte(3);
+        r.benutze("Bombe");
+
+        for(int i=0; i<3; i++) {
+            while(r.einsVorSammle());
+            r.dreheUm();
+        }
+        r.dreheLinks();
+        if(r.einsVorSammle()) {
+            r.dreheRechts();
+            for(int i=0; i<4; i++) {
+                while(r.einsVorSammle());
+                r.dreheUm();
+            }
+        } else {
+            r.dreheRechts();
+        }
+        r.benutze("Bombe");
+        for(int i=0; i<2; i++) {
+            while(r.einsVorSammle());
+            r.dreheUm();
+        }
+        r.dreheLinks();
+        if(r.einsVorSammle()) {
+            r.dreheRechts();
+            for(int i=0; i<2; i++) {
+                while(r.einsVorSammle());
+                r.dreheUm();
+            }
+        }
+
+        roboter1.holeAufzug();
+        r = roboter2;
+        r.ablegen("Bombe");
+        r.laufeBisWand();
+        r.fahreAufzug(8,true);
+        r.dreheRechts();
+        r.geheSchritte(3);
+        roboter1.dreheUm();
+        roboter1.einsVor();
+        roboter1.aufnehmen();
+        roboter1.benutze("Bombe");
+        for(int j=0; j<4; j++) {
+            for(int i=0; i<2; i++) {
+                while(roboter1.einsVorSammle());
+                roboter1.dreheUm();
+            }
+            roboter1.dreheRechts();
+            roboter1.einsVorSammle();
+            roboter1.dreheLinks();
+        }
+
+        r.benutze("Bombe");
+        for(int i=0; i<6; i++) {
+            while(r.einsVorSammle());
+            r.dreheUm();
+        } 
+
+    }
+
+    /*#
+     * -------------------------------------------------------------------
+     * Bitte so lassen - diese Methode wird nur von euren Lehrer verwendet
+     */
+    public void nehmeKontaktAuf() {
+        List<AB9> l9 = ((RoboterWelt)getWorld()).getObjects(AB9.class);
+        if (l9.size()>0) {
+            aufzugRoboter = l9.get(0);
+            sprengRoboter1 = l9.get(1);
+            sprengRoboter2 = l9.get(2);
+            legeRoboter = l9.get(3);
+        }
+        List<AB10> l10 = ((RoboterWelt)getWorld()).getObjects(AB10.class);
+        if (l10.size()>0) {
+            roboter1 = l10.get(0);
+            roboter2 = l10.get(1);
+            roboter3 = l10.get(2);
+        }
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/Gegenstand.java

@@ -0,0 +1,145 @@
+import greenfoot.*;
+import java.util.*;
+import javax.swing.JOptionPane;
+
+/** Die Klasse Gegenstand fasst alle in der Welt liegenden Actors zusammen,
+ * die bewegt werden können.
+ */
+public class Gegenstand extends Actor
+{
+    private int typ;
+    private static String[] typen = {"Akku","Schraube","Brennstab","Schluessel","Oelfleck","Portal","Strom","Feuer","Feuerloescher","Fass","Atommuell","Bombe", "Kontaktplatte","Aufzug","Diamant"};
+    private boolean[] moveable = {true, true, true, true, false, false, false, false, true, false, false, true, false, false, true};
+    private int[] schaden = {0, 0, 0, 0, 20, 0, 50, 40, 0, 0, 0, 0, 0, 0, 0};
+    private int[] lebensdauer = {1, 1, 1, 1, 0, 1000, 0, 0, 5, 1000, 1000,1, 1000, 1000,1000}; 
+    private Schalter schalter = null;
+
+    /** erzeugt einen neuen Gegenstand vom angegeben Typ
+     * @param name Typ des Gegenstands ("Akku","Schraube","Brennstab","Schluessel","Oelfleck","Portal","Strom","Feuer","Feuerloescher","Fass","Atommuell","Bombe", "Kontaktplatte", "Aufzug", "Diamant")
+     */
+    public Gegenstand(String name) {
+        super();
+        this.typ = -1;
+
+        for(int i = 0; i < typen.length; i++) {
+            if (name.equals(typen[i])) {
+                this.typ = i;
+            }
+        }
+        if(this.typ == -1) {
+            JOptionPane.showMessageDialog(null, "Ich kenne kein(e) "+name+". Daher erzeuge ich einen Akku.", "Meldung!",
+                JOptionPane.INFORMATION_MESSAGE);
+            this.typ = 0;
+        }
+        this.setImage("images/"+typen[typ]+".png");
+    }
+
+    /** erzeugt einen Standardgegenstand (Akku)
+     */
+    public Gegenstand() {
+        super();
+        this.typ = 0;
+        this.setImage("images/Akku.png");
+    }
+
+    /** untersucht, ob name eine korrekte Bezeichnug für einen Gegenstand ist
+     * @return erg true, wenn name korrekt ist
+     */
+    public static boolean istGegenstand(String name) {
+        boolean erg = false;
+        for(int i = 0; i < typen.length; i++) {
+            if (name.equals(typen[i])) {
+                erg = true;
+            }
+        }
+        return erg;
+    }
+
+    /** liefert den Typ des Gegenstands
+     * @return Typ ("Akku","Schraube","Brennstab","Schluessel","Oelfleck","Portal","Strom","Feuer","Feuerloescher","Fass","Atommuell","Bombe", "Kontaktplatte", "Aufzug", "Diamant")
+     */
+    public String getName() {
+        return this.typen[typ];
+    }
+
+    /** liefert, ob der Gegenstand vom Roboter aufgenommen werden kann
+     * @return true, wenn der Gegenstand weggetragen werden darf.
+     */
+    public boolean istBeweglich() {
+        return this.moveable[typ];
+    }
+
+    /** liefert den Schaden an der Energieversorgung, wenn der Roboter mit dem Gegenstand
+     * auf einem Feld ist.
+     * @return abgezogen Energiepunkte
+     */
+    public int getSchaden() {
+        return this.schaden[typ];
+    }
+
+    /** liefert die Anzahl der Einsätze bevor der Gegenstand verbraucht ist
+     * @return z.B. 1 für Akku, 5 für Feuerlöscher
+     */
+    public int getLebensdauer() {
+        return this.lebensdauer[typ];
+    }
+
+    /** liefert einen Schalter, der mit diesem Gegenstand verbunden ist (z.B. bei Kontaktplatten)
+     * @return Schalterobjekt
+     */
+    public Schalter getSchalter() {
+        return this.schalter;
+    }
+
+    /** Verbindet diese Objekt mit einem Schalter (z.B. bei Kontaktplatten)
+     * @param s Schalterobjekt
+     */
+    public void setSchalter(Schalter s) {
+        this.schalter = s;
+    }
+
+    /** Benutzt das Objekt und setzt dadurch die Lebensdauer herunter
+     */
+    public void benutze() {
+        this.lebensdauer[typ]--;
+    }
+
+    // Systembedingte Routinen    
+    /**
+     * Wird aufgerufen, wenn der Roboter in die Welt gesetzt wird; 
+     * erweitert nach Vorschlag P.Henriksen 29.6.08
+     */
+    protected void addedToWorld(World world) {
+        // Roboter kann nicht auf eine Wand oder einen anderem Roboter gesetzt werden
+        Actor wand = getOneObjectAtOffset(0, 0, Wand.class);
+        if (wand != null) {
+            world.removeObject(this);
+        }
+    }
+
+    /**
+     * setLocation(x,y) fuer Roboter wird ueberschrieben, um nicht auf Wand oder
+     * anderen Roboter ziehen zu koennen!
+     * -- setzt den Roboter auf eine Kachel, deren Spalte x sowie Reihe y du 
+     * hier vorgibst. Die Nummerierung beginnt jeweils bei 0 !!) 
+     */
+    public void setLocation(int x, int y) {
+        List wand = getWorld().getObjectsAt(x, y, Wand.class);
+        List g = getWorld().getObjectsAt(x,y, Gegenstand.class);
+        
+        if (wand.isEmpty() && g.isEmpty()) {
+            super.setLocation(x, y);
+        }
+    }
+    /* setLocation(x,y) und setRotation(x) koennen nicht verborgen werden, 
+     * weil sie schon in der Oberklasse Actor public sind. 
+     */
+
+    /**
+     * setRotation(x) fuer Roboter wird verhindert! 
+     * Es ist unnoetig, da Roboter sich nur in vier Richtungen drehen koennen!
+     */
+    public void setRotation(int x) {
+        // nichts machen!!
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/Message.java

@@ -0,0 +1,23 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot und MouseInfo)
+
+/**
+ * Ergänzen Sie hier eine Beschreibung für die Klasse Message.
+ * 
+ * @author (Ihr Name) 
+ * @version (eine Versionsnummer oder ein Datum)
+ */
+public class Message extends Actor
+{
+    /**
+     * Act - tut, was auch immer Message tun will. Diese Methode wird aufgerufen, 
+     * sobald der 'Act' oder 'Run' Button in der Umgebung angeklickt werden. 
+     */
+    public Message (String text) {
+        GreenfootImage t = new GreenfootImage(text,30, new Color(255,255,255),new Color(200,100,100,0));
+        GreenfootImage mitRand = new GreenfootImage(t.getWidth()+60, t.getHeight()+30);
+        mitRand.setColor(new Color(150,50,50,220));
+        mitRand.fillRect(0,0, mitRand.getWidth(), mitRand.getHeight());
+        mitRand.drawImage(t, 30, 15);
+        setImage(mitRand);
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/ReadWrite.java

@@ -0,0 +1,196 @@
+import java.io.*;
+import java.util.*;
+
+/**
+ * Die Klasse ReadWrite erstellt geheimCodes und steuert damit den Ablauf
+ * und die Reihenfolge der Einsaetze
+ */
+class ReadWrite
+{
+    private String dateiName;
+
+    /** Erzeugt neues Dateizugriffsobjekt
+     */
+    public ReadWrite () {
+        dateiName = "secret";
+    }
+
+    /** Schreibt einen neuen Levelstand in die Datei, wenn dieser höher als der bisherige ist
+     * (dies verhindert ein Zurückfallen auf ein niedrigeres Level, wenn ein Einsatz erneut ausgeführt wird.)
+     * @param level neuer Level
+     */
+    public void writeLevel(int level) {
+        writeLevel(level,false);
+    }
+
+    /** Schreibt einen neuen Levelstand in die Datei. 
+     * @param level neuer Level
+     * @param down  darf der neue Level auch niedriger als der alte sein (true = gezieltes Zurücksetzen)
+     */
+    public void writeLevel(int level, boolean down) {
+        if (level > getLevel() || down) {  //Damit nicht wieder in einen kleineren Level zurückgefallen wird
+            Random r = new Random();
+            Scanner s = new Scanner(this.read());
+            long z1 = s.nextLong();
+            long z2 = r.nextInt()+362734617;
+            z2 = z2 - (z2 % 131 - z1% 131);
+            while (z2 % 31 != level) {
+                z2 += 131;
+            }
+            this.append(""+z2);
+        }
+    }
+
+    /** Erzeugt eine neue Secret-Datei mit Level 1
+     */
+    public void init() {
+        Random r = new Random();
+        long z1 = r.nextInt()+212312312;
+        long z2 = r.nextInt()+362734617;
+        z2 = z2 - (z2 % 131 - z1% 131);
+        while (z2 % 31 != 1) {
+            z2 += 131;
+        }
+        write(""+z1);
+        append(""+z2);
+    }
+
+    /** Liefert den zuletzt gespeicherten Level
+     * @return Level
+     */
+    public int getLevel() {
+        int level = 1;
+        String z = read();
+        if (z.equals("")) {
+            init();
+        }
+        try {
+            Scanner s = new Scanner(read());
+            long z1 = s.nextLong();
+            s = new Scanner(readLastLine());
+            long z2 = s.nextLong();
+
+            if (z1 % 131 != z2 %131) {
+                init();
+                level = 1;
+            } else {
+                level = (int) (z2 % 31);
+            }
+        } catch(Exception e) {
+            level = -1;
+        }
+        return level;
+    }
+
+    /** Liefert den höchsten bisher gespeicherten Level
+     * @return maximal erreichter Level
+     */
+    public int getMaxLevel() {
+        int level = 1;
+        String z = read();
+        if (z.equals("")) {
+            init();
+            return 1;
+        }
+
+        try {
+            FileReader fr = new FileReader(dateiName);
+            BufferedReader br = new BufferedReader(fr);
+            String zeile = br.readLine();
+            Scanner s = new Scanner(zeile);
+            long z1 = s.nextLong();
+            while(br.ready()) {
+                zeile = br.readLine();
+                s = new Scanner(zeile);
+                long z2 = s.nextLong();
+
+                if (z1 % 131 != z2 %131) {
+                    init();
+                    level = 1;
+                    break;
+                } else {
+                    if (level < (int) (z2 % 31)) {
+                        level = (int) (z2 % 31);
+                    }
+                }
+            }
+            br.close();
+            return level;
+        }
+        catch (IOException e) {
+            return level;
+        }
+
+    }
+
+    /** Liest die erste Zeile aus der Secretdatei
+     * @return erste Zeile
+     */
+    public String read()
+    {
+        try {
+            FileReader fr = new FileReader(dateiName);
+            BufferedReader br = new BufferedReader(fr);
+            String zeile = br.readLine();
+            br.close();
+            return zeile;
+        }
+        catch (IOException e) {
+            return "";
+        }
+    }
+
+    /** Liest die letzte Zeile aus der Secretdatei
+     * @return letzte Zeile
+     */  
+    public String readLastLine()
+    {
+        try {
+            FileReader fr = new FileReader(dateiName);
+            BufferedReader br = new BufferedReader(fr);
+            String zeile = br.readLine();
+            while(br.ready()) zeile = br.readLine();
+            br.close();
+            return zeile;
+        }
+        catch (IOException e) {
+            return "";
+        }
+    }
+
+    /** Schreibt eine neue Datei mit einer Zeile
+     * @param text 1. Zeile der Datei
+     */
+    public boolean write(String text)
+    {
+        try {
+            FileWriter fw = new FileWriter(dateiName);
+            BufferedWriter bw = new BufferedWriter(fw);
+            bw.write(text);
+            bw.newLine();
+            bw.close();
+            return true;
+        }
+        catch (IOException e) {
+            return false;
+        }
+    }
+
+    /** Hängt eine Zeile an die Secret-Datei an
+     * @param text anzuhängende Zeile
+     */
+    public boolean append(String text)
+    {
+        try {
+            FileWriter fw = new FileWriter(dateiName, true);
+            BufferedWriter bw = new BufferedWriter(fw);
+            bw.write(text);
+            bw.newLine();
+            bw.close();
+            return true;
+        }
+        catch (IOException e) {
+            return false;
+        }
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/Roboter.java

@@ -0,0 +1,801 @@
+import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.util.*;
+import javax.swing.JOptionPane;
+
+/**
+ * Diese Klasse ist die Oberklasse fuer die Roboter "Robita", "Robson" und "Robby". 
+ * Programme sollen nur in den Unterklassen 
+ * implementiert werden, da diese Klasse fuer Java-Beginner sehr komplex ist.
+ * Ein Roboter kann sich felderweise in die vier Himmelsrichtungen im Szenario bewegen. 
+ * Ueber Sensoren kann er Informationen ueber seine Umwelt erhalten.
+ */
+
+public class Roboter extends Actor
+{
+    private int energie; //Energie in Prozent
+    private ArrayList<Gegenstand> inventar;
+    private GreenfootImage originalImage;
+
+    /**
+     * Ein Objekt der Klasse Roboter wird exempliert bzw. instanziert.
+     */
+    public Roboter()
+    {
+        inventar = new ArrayList<Gegenstand>();
+        energie=100;
+        originalImage = new GreenfootImage(this.getImage());
+        zeichneRobotImage();
+    }
+
+    /**
+     * Gibt die Anzahl der Gegenstaende, die Roboter traegt, zurueck.
+     * @return Anzahl der Gegenstaende
+     */
+    public int getAnzahl() {
+        return inventar.size();
+    }
+
+    /**
+     * Gibt die Anzahl der Gegenstaende einer bestimmten Art zurueck.
+     * @param name Art der Gegenstands (z.B. "Schluessel")
+     * @return Anzahl der Gegenstaende
+     */
+    public int getAnzahl(String name) {
+        int anz = 0;
+        if (Gegenstand.istGegenstand(name)) {
+            for (Gegenstand g : inventar) {
+                if (g.getName().equals(name)) {
+                    anz++;
+                }
+            }
+        } else 
+        {
+            melde(""+name+" ist keine gültige Bezeichnung für einen Gegenstand", true);
+        }
+        return anz;
+    }
+
+    /**
+     * Gibt die Restenergie des Roboters zurück
+     * @return Energiereserve (0-100)
+     */
+    public int getEnergie() {
+        return energie;
+    }
+
+    /**
+     * Reduziert die Restenergie des Roboters um den angegebenen Wert.
+     * @param verlust Anzahl der verbrauchten Energiepunkte
+     */
+    public void verbraucheEnergie(int verlust) {
+        energie = energie-verlust;
+        if (energie < 0) energie=0;
+        zeichneRobotImage();
+    }
+
+    /**
+     * Gibt zurueck, ob die Energie des Roboters verbraucht ist.
+     * @return true, wenn Restenergie =0, sonst false
+     */
+    public boolean istEnergieLeer() {
+        if (getEnergie()==0) return true;
+        else return false;
+    }
+
+    /**
+     * Gibt die x-Koordinate zurück, wenn der Roboter einen Schritt nach vorne macht.
+     * @return x-Koordinate
+     */
+    private int xVor() {
+        switch(this.getRotation())
+        {
+            case 0 : return getX()+1; 
+            case 180 : return getX()-1; 
+        }
+        return getX();
+    }
+
+    /**
+     * Gibt die y-Koordinate zurück, wenn der Roboter einen Schritt nach vorne macht.
+     * @return y-Koordinate
+     */
+
+    private int yVor() {
+        switch(this.getRotation())
+        {
+            case 90 : return getY()+1;  
+            case 270 : return getY()-1; 
+        }
+        return getY();
+    }
+
+    /**
+     * Der Roboter geht einen Schritt in die Pfeilrichtung.
+     * Das macht er nur, wenn sich keine Wand vor ihm befindet oder
+     * er nicht an der Grenze der Welt zur Wand blickt.
+     */
+    public void einsVor()
+    {
+        int possible=0;
+        if (!this.istVorneFrei()) possible = 1;
+        if (energie < 1) possible = 2;
+        if (istVorne("Fass") || istVorne("Atommuell")) {
+            if(this.getWorld().getObjectsAt(getX()+(xVor()-getX())*2,getY()+(yVor()-getY())*2, null).size() > 0)  {
+                possible = 1;
+            }  else {
+                energie -= 5;
+                List actors = this.getWorld().getObjectsAt(xVor(), yVor(), null);
+                Gegenstand fass = (Gegenstand) (actors.get(0));
+                fass.setLocation(getX()+(xVor()-getX())*2,getY()+(yVor()-getY())*2);
+            }
+        }
+        int[][] map = ((RoboterWelt) getWorld()).getMap();
+        if ((map[getY()][getX()] == 30 || map[getY()][getX()] == 7) && yVor() != getY() && !istAufGegenstand("Aufzug")) // Aufzug
+        {
+            possible = 3;
+        }
+
+        if (possible==0)
+        {   
+            Schalter s=null; boolean on=false;
+            if (istAufGegenstand("Kontaktplatte")) {
+                s = gibGegenstandUnterRoboter().getSchalter();
+                on = true;
+            }
+            energie--;
+            this.setLocation(xVor(), yVor());
+            if (istAufGegenstand("Portal")) {
+                if (this instanceof AB1) {
+                    if (this.getAnzahl("Schraube")>=2) {
+                        ReadWrite secret = new ReadWrite();
+                        secret.writeLevel(2);
+                        Greenfoot.delay(1);
+                        melde("Sehr gut. Level 1 abgeschlossen. Gehe zu Level 2.",false);
+                        Greenfoot.setWorld(new RoboterWelt());
+                    }
+                    else {
+                        melde("Du musst erst noch mind. 2  Schrauben einsammeln, um das AB 1 abzuschließen.",false);
+                    } // end of if-else
+
+                }
+                energie = 100;
+            }
+            if (istAufGegenstand("Kontaktplatte") ) {
+                s = gibGegenstandUnterRoboter().getSchalter();
+                on = false;
+            }
+            if (s != null) {
+                if (on) s.anschalten(); else s.ausschalten();
+            }
+            if (istAufGegenstand()) {
+                if (energie > gibGegenstandUnterRoboter().getSchaden()) energie -= gibGegenstandUnterRoboter().getSchaden();
+                else energie = 0;
+            }
+            zeichneRobotImage();
+            Greenfoot.delay(1);
+            ((RoboterWelt) getWorld()).schwerkraftAnwenden();
+        }
+        else
+        {
+            switch(possible) {
+                case 1:
+                warne("Ich kann keinen Schritt machen!\nEin Hindernis ist im Weg!",this); break;
+                case 2:
+                warne("Ich kann keinen Schritt machen!\nIch habe keine Energie mehr!",this); break;
+                case 3:
+                warne("Ich kann keinen Schritt machen!\nIn einem Aufzug braucht man die Plattform,\n um hoch oder runter zu fahren.",this); break;
+            }                
+        }
+    }
+
+    /**
+     * Der Roboter dreht sich um 90 Grad nach rechts (aus der Sicht des Roboters).
+     */
+    public void dreheRechts()
+    {
+        setRotation((getRotation()+90)%360);
+        zeichneRobotImage();
+        Greenfoot.delay(1);
+    }
+
+    /**
+     * Der Roboter dreht sich um 180 Grad nach rechts (aus der Sicht des Roboters).
+     */
+    public void dreheUm()
+    {
+        dreheRechts();
+        dreheRechts();
+    }
+
+    /**
+     * Der Roboter dreht sich um 90 Grad nach links (aus der Sicht des Roboters).
+     */
+    public void dreheLinks()
+    {
+        setRotation((getRotation()+270)%360);
+        zeichneRobotImage();
+        Greenfoot.delay(1);
+    }
+
+    /**
+     * Gibt das erste Gegenstandsobjekt zurück, das der angegebenen Art entspricht.
+     * @param name Art des gesuchten Gegenstands
+     * @return Gegenstandsobjekt
+     */
+    private Gegenstand getInventar(String name) {
+        if (Gegenstand.istGegenstand(name)) {
+            for(Gegenstand g: inventar) {
+                if (g.getName().equals(name)) {
+                    return g;
+                }
+            }
+        }
+        else {
+            melde(""+name+" ist kein gültiger Gegenstand.",true);
+        }
+        return null;
+    }
+
+    /**
+     * Gibt zurueck, ob der Roboter mindestens einen Gegenstand der angegeben Art besitzt.
+     * @param name Art des gesuchten Gegenstands
+     * @return true, wenn der Roboter einen derartigen Gegenstand hat, sonst false
+     */
+    public boolean hatGegenstand(String name) {
+        if (Gegenstand.istGegenstand(name)) {
+            for(Gegenstand g: inventar) {
+                if (g.getName().equals(name)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            melde(""+name+" ist kein gültiger Gegenstand.",true);
+        }
+        return false;
+    }
+
+    /**
+     * Gibt dem Roboter eine bestimmte Anzahl von Gegenstaenden einer Art
+     * @param name Art des Gegenstands
+     * @anzahl gewuenschte Anzahl
+     */
+    public void setAnzahlVonGegenstand(String name, int anzahl) {
+        if (Gegenstand.istGegenstand(name)) { 
+            for (int i=0; i<anzahl; i++) {
+                inventar.add(new Gegenstand(name));
+            }
+            zeichneRobotImage();
+        }
+        else {
+            melde(""+name+" ist kein gültiger Gegenstand.",true);
+        }
+    }
+
+    /**
+     * Benutzt den angegebenen Gegenstand. Es koennen nur Schluessel, Schalter, Bombe, Feuerloescher und Akku benutzt werden.
+     * Dabei kann ein Schluessel nur direkt vor einem Schloss benutzt werden. Eine Bombe sprengt einen Bereich frei. Der Feuerloescher 
+     * kann ein direkt vor dem Roboter befindliches Feuer loeschen. Der Akku erhoeht die Restenergie des Roboters.
+     * @param name Art des zu benutzenden Gegenstands ("Schluessel", "Schalter", "Bombe", "Feuerloescher", "Akku")
+     */
+    public void benutze(String name) {
+        if (!Gegenstand.istGegenstand(name) && !Wand.istWandtyp(name)) { 
+            melde(""+name+" ist keine gültige Bezeichnung.",true);
+            return;
+        } 
+        if (name.equals("Schalter")) {
+            if (istVorne("Schalter")) {
+                List actors = this.getWorld().getObjectsAt(xVor(), yVor(), Wand.class);
+                Wand w = (Wand) (actors.get(0));
+                if (w.getSchalter() != null) w.getSchalter().umschalten();
+                Greenfoot.delay(1);
+            } else {
+                warne("Du stehst gar nicht vor einem Schalter.\n Wie willst du ihn benutzen?",this);
+            }
+        }
+
+        if (name.equals("Akku") || name.equals("Feuerloescher") || name.equals("Schluessel") || name.equals("Bombe")) {
+            if (this.getAnzahl(name)>0) {
+                Gegenstand g = this.getInventar(name);
+                g.benutze();
+                if (g.getLebensdauer() == 0) inventar.remove(g);
+                if (name.equals("Akku")) {
+                    energie += 40;
+                    if (energie >100) energie = 100;
+                }
+                if (name.equals("Feuerloescher")) {
+                    if (istVorne("Feuer")) {
+                        List actors = this.getWorld().getObjectsAt(xVor(), yVor(), Gegenstand.class);
+                        this.getWorld().removeObject((Actor) (actors.get(0)));
+                    }
+                }
+                if (name.equals("Schluessel")) {
+                    if (istVorne("Schloss")) {
+                        // g.benutze();         // Dirk: ist doch schon vorher aufgerufen worden - oder?
+                        if (g.getLebensdauer() == 0) inventar.remove(g);
+                        List actors = this.getWorld().getObjectsAt(xVor(), yVor(), Wand.class);
+                        Wand w = (Wand) (actors.get(0));
+                        if (w.getSchalter() != null) w.getSchalter().umschalten();
+                    } else {
+                        inventar.add(new Gegenstand("Schluessel"));
+                    }
+                }
+                if (name.equals("Bombe")) {
+                    Schalter s1 = new Schalter(getWorld());
+                    int[][] level1 = {{ -1, -1, -1 , -1, -1},{ -1, -1, -1, -1, -1},{ -1, -1, 40, -1, -1},{ -1, -1, -1, -1, -1},{ -1, -1, -1 ,-1, -1}};
+                    int[][] level2 = {{ -1,-1, -1 ,-1, -1},{ -1, 6, 40 , 6, -1},{ -1, 6, 40 , 6, -1},{-1, 6, 40 , 6, -1},{ -1, -1, -1 ,-1, -1}};
+                    int[][] level3 = {{ -1, -1, -1 ,-1, -1},{ -1, 40, 40 , 40, -1},{ -1, 40, 6 , 40, -1},{ -1, 40, 40 , 40, -1},{ -1, -1, -1 ,-1, -1}};
+                    int[][] level4 = {{ -1, -1, -1 ,-1, -1},{ -1, 6, 6 , 6, -1},{ -1, 6, 6 , 6, -1},{ -1, 6, 6 , 6, -1},{ -1, -1, -1 ,-1, -1}};
+                    int platzFuerAkku = Greenfoot.getRandomNumber(9);
+                    int myrotation = getRotation();
+                    /*                   switch (platzFuerAkku) {
+                    case 0: level4[1][1]=38; break;
+                    case 1: level4[1][2]=38; break;
+                    case 2: level4[1][3]=38; break;
+                    case 3: level4[2][1]=38; break;
+                    case 4: level4[2][2]=38; break;
+                    case 5: level4[2][3]=38; break;
+                    case 6: level4[3][1]=38; break;
+                    case 7: level4[3][2]=38; break;
+                    case 8: level4[3][3]=38; break;
+                    }
+                    for (int i=0; i<2; i++){
+                    int platzFuerKontaktplatte=0;
+                    do {
+                    platzFuerKontaktplatte = Greenfoot.getRandomNumber(9);
+                    } while(platzFuerKontaktplatte == platzFuerAkku);
+                    switch (platzFuerKontaktplatte) {
+                    case 0: level4[1][1]=31; break;
+                    case 1: level4[1][2]=31; break;
+                    case 2: level4[1][3]=31; break;
+                    case 3: level4[2][1]=31; break;
+                    case 4: level4[2][2]=31; break;
+                    case 5: level4[2][3]=31; break;
+                    case 6: level4[3][1]=31; break;
+                    case 7: level4[3][2]=31; break;
+                    case 8: level4[3][3]=31; break;
+                    }
+                    }*/
+                    int x = getX()-2;
+                    int y = getY()-2;
+                    s1.setPosition(x,y, level2, level1);
+                    s1.ausschalten();
+                    energie = energie - 10;
+                    if (energie < 0) energie = 0;
+                    zeichneRobotImage();
+                    // getWorld().removeObject(this);
+
+                    Greenfoot.delay(2);
+                    s1.anschalten();
+                    setRotation((getRotation()+180)%360);
+                    if(istVorneFrei())  this.setLocation(xVor(), yVor());
+                    setRotation(myrotation);
+                    energie = energie - 10;
+                    if (energie < 0) energie = 0;
+                    zeichneRobotImage();
+                    Greenfoot.delay(2);
+
+                    s1.setPosition(x,y, level4, level3);
+                    s1.ausschalten();
+                    setRotation((getRotation()+180)%360);
+                    if(istVorneFrei())  this.setLocation(xVor(), yVor());
+                    setRotation(myrotation);
+                    Greenfoot.delay(2);
+                    s1.anschalten();
+
+                }
+                zeichneRobotImage();
+                Greenfoot.delay(1);
+                ((RoboterWelt) this.getWorld()).schwerkraftAnwenden();
+            } else {
+                warne("Du hast gar kein(e) "+name+",\n den/die du benutzen könntest.", this);
+            }
+        }
+    }
+
+    /**
+     * Liefert genau dann true, wenn auf der Kachel, auf der sich der
+     * aufgerufene Roboter gerade befindet, ein beliebiger Gegenstand befindet.
+     * @return true, wenn der Roboter auf einem Gegenstand steht, sonst false
+     */
+    public boolean istAufGegenstand() {
+        List g = getWorld().getObjectsAt(getX(), getY(), Gegenstand.class);
+        if (g.size() > 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Liefert genau dann true, wenn auf der Kachel, auf der sich der
+     * aufgerufene Roboter gerade befindet, ein Gegenstand mit dem angegebnen Namen befindet.
+     * @param name Einer der Gegenstaende ("Schluessel", "Schalter", "Bombe", "Feuerloescher", "Brennstab", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer", "Aufzug")
+     * @return true, wenn der Roboter auf einem Gegenstand steht, sonst false
+     */
+    public boolean istAufGegenstand(String name) {
+        if (!Gegenstand.istGegenstand(name)) { 
+            melde(""+name+" ist kein gültiger Gegenstand.",true);
+            return false;
+        } 
+        List g = getWorld().getObjectsAt(getX(), getY(), Gegenstand.class);
+        if (g.size() > 0) {
+            return ((Gegenstand) (g.get(0))).getName().equals(name);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Gibt den Gegenstand zurueck, auf dem sich ein Roboter befindet 
+     * @return Gegenstand (entweder "Schluessel", "Schalter", "Bombe", "Feuerloescher", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer", "Aufzug")
+     */
+    private Gegenstand gibGegenstandUnterRoboter() {
+        List g = getWorld().getObjectsAt(getX(), getY(), Gegenstand.class);
+        if (g.size() > 0) {
+            return (Gegenstand) (g.get(0));
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Liefert genau dann true, wenn der aufgerufene Roboter keinen Gegenstand bei sich hat.
+     * @return true, wenn der Roboter keinen Gegenstand mit sich traegt, sonst false
+     */
+    public boolean istInventarLeer() {
+        return inventar.size() == 0;
+    }
+
+    /**
+     * Der Roboter legt einen Gegenstand aus seinem Vorrat auf dem Feld ab.
+     * @param name Einer der Gegenstaende ("Schluessel", "Schalter", "Bombe", "Brennstab", "Feuerloescher", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer")
+     */      
+    public void ablegen(String name)
+    {
+        if (!Gegenstand.istGegenstand(name)) { 
+            melde(""+name+" ist kein gültiger Gegenstand.",true);
+            return;
+        } 
+        if (getAnzahl(name)>0) {
+            if (!istAufGegenstand() || istAufGegenstand("Oelfleck")|| istAufGegenstand("Kontaktplatte")) { // Dirk: Ablegen auf Kontaktplatte geaendert! 
+                int aktuellesX = this.getX();
+                int aktuellesY = this.getY();
+                for(Gegenstand g: inventar) {
+                    if (g.getName().equals(name)) {
+                        inventar.remove(g);
+                        this.getWorld().addObject(g, aktuellesX, aktuellesY);
+                        zeichneRobotImage();
+                        break;
+                    }
+                }
+                ((RoboterWelt) this.getWorld()).schwerkraftAnwenden();
+            }
+            else warne("Hier liegt schon etwas oder\nman darf hier nichts ablegen!",this); 
+        }
+        else warne("Ich habe kein(e) "+name+" zum Ablegen!",this); 
+    }
+
+    /**
+     * Der Roboter nimmt einen Gegenstand, der sich auf seinem Feld befindet in seinen Vorrat auf.
+     * Falls er nicht auf einem Gegenstand steht, gibt er eine Warnung aus.
+     * Roboter haben nur eine begrenzte Kapazitaet. Sie koennen maximal 99 Gegenstaende mit sich tragen.
+     * Falls er einen 100. Gegenstand aufnehmen moechte, wird auch eine entsprechende Warnung ausgegeben.
+     */      
+    public void aufnehmen ()
+    {
+        if (getAnzahl()<=99) // von Dirk von < auf <= veraendert!
+        {
+            Gegenstand g = (Gegenstand)this.getOneObjectAtOffset(0, 0, Gegenstand.class);
+            if(g != null)
+            {
+                if (g.istBeweglich()) {
+                    this.getWorld().removeObject(g);
+                    inventar.add(g);
+                    zeichneRobotImage();
+                    ((RoboterWelt) getWorld()).schwerkraftAnwenden();
+
+                } else {
+                    warne("Ein(e) "+g.getName()+" kann man nicht aufheben", this);
+                }
+            }
+            else
+            {
+                warne("Hier ist nichts zum Aufheben!",this);
+            }
+        }
+        else warne("Hab keinen Platz für weitere Gegenstände!",this); 
+    }
+
+    /**
+     * Diese Methode setzt einen Roboter vor den Roboter, der diese Methode aufruft.
+     * Ist vor ihm kein Platz, wird eine Warnung ausgegeben.
+     * @param r der Hilfsroboter, der eingesetzt werden soll
+     */
+    public void gehilfeEinsetzen(Roboter r) {
+        if (istVorneFrei() && getWorld().getObjectsAt(xVor(), yVor(), Roboter.class).isEmpty()) {
+            this.getWorld().addObject(r, xVor(), yVor());
+        } else {
+            warne("Vor dir ist kein Platz für einen Gehilfen!",this);
+        }
+    }
+
+    /**
+     * Der Sensor ueberprueft, ob vor dem Roboter Hindernisse stehen oder nicht
+     * @return true, wenn vor dem Roboter frei ist, sonst false
+     */     
+    public boolean istVorneFrei()
+    {
+        return !istWandVorne() && (this.getWorld().getObjectsAt(xVor(),yVor(), Roboter.class).size() == 0);   
+    }
+
+    /**
+     * Liefert genau dann true, wenn sich vor dem Roboter ein Gegenstand mit dem angegebnen Namen befindet.
+     * @param name Einer der Gegenstaende ("Schluessel", "Schalter", "Schloss", "Bombe", "Feuerloescher", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer", "Aufzug")
+     * @return true, wenn der Roboter vor dem Gegenstand mit dem Namen name steht, sonst false
+     */
+    public boolean istVorne(String name) {
+        if (!Gegenstand.istGegenstand(name) && !Wand.istWandtyp(name)) {
+            melde(name+" ist keine gültige Bezeichnung", true);
+            return false;
+        }
+        List actors = this.getWorld().getObjectsAt(xVor(), yVor(), null);
+        boolean found = false;
+        for(int i = 0; i < actors.size(); i++) {
+            Object o = actors.get(i);
+            if (o instanceof Gegenstand) {
+                if (((Gegenstand) o).getName().equals(name)) {
+                    found = true;
+                    break;
+                }
+            }
+            if (o instanceof Wand) {
+                if (((Wand) o).getName().equals(name)) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+
+    /**
+     * Der Sensor ueberprueft, ob sich in Laufrichtung des Roboters eine Wand befindet.
+     * @return true, wenn der Roboter vor einer Wand steht, sonst false
+     */
+    public boolean istWandVorne()
+    {
+        return (this.getWorld().getObjectsAt(xVor(),yVor(), Wand.class).size() > 0);
+    } 
+
+    /**
+     * Der Sensor ueberprueft, ob sich rechts der Laufrichtung eine Wand befindet.
+     * @return true, wenn sich rechts von dem Roboter eine Wand befindet, sonst false
+     */    
+    public boolean istWandRechts()
+    {
+        int lRichtung = getRotation();
+
+        if (lRichtung == 0 && this.getOneObjectAtOffset(0, 1, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        if (lRichtung == 90 && this.getOneObjectAtOffset(-1, 0, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        if (lRichtung == 180 && this.getOneObjectAtOffset(0, -1, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        if (lRichtung == 270 && this.getOneObjectAtOffset(1, 0, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        return false;
+    }
+
+    /**
+     * Der Sensor ueberprueft, ob sich links der Laufrichtung eine Wand befindet.
+     * @return true, wenn sich links von dem Roboter eine Wand befindet, sonst false
+     */  
+    public boolean istWandLinks()
+    {
+        int lRichtung = getRotation();
+
+        if (lRichtung == 0 && this.getOneObjectAtOffset(0, -1, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        if (lRichtung == 90 && this.getOneObjectAtOffset(1, 0, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        if (lRichtung == 180 && this.getOneObjectAtOffset(0, 1, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        if (lRichtung == 270 && this.getOneObjectAtOffset(-1, 0, Wand.class)!= null)
+        {
+            return true;     
+        }
+
+        return false;
+    }
+
+    /**
+     * Eine private Methode, die dafuer sorgt, dass der "Aufdruck" auf dem Roboter (Anzahl der Gegenstaende), der Akkustandsbalken und
+     * der Richtungspfeil aktualisiert werden
+     */
+    private void zeichneRobotImage()
+    {
+        final int x=17;
+        final int y=18;
+        final int breite = 14;
+        final int hoehe = 12;
+        this.setImage(new GreenfootImage(originalImage));
+        this.getImage().setColor(Color.WHITE);
+        this.getImage().fillRect(x, y, breite, hoehe);
+        this.getImage().setColor(Color.BLACK);
+        this.getImage().drawRect(x, y, breite, hoehe);
+        this.getImage().setFont(new Font("Arial",false,false,10));
+        String ziffern;
+        int anz = inventar.size();
+        if (anz>=0 && anz<10) ziffern="0"+anz;
+        else if (anz>=100) ziffern=">>";
+        else ziffern=""+anz;
+        this.getImage().drawString(ziffern, x+2, y+hoehe-2);
+        zeichneEnergie();
+
+        this.getImage().drawImage(new GreenfootImage("images/pfeil"+getRotation()+".png"), 40, 2);
+        this.getImage().rotate(-getRotation());
+    }
+
+    /**
+     * Zeichne / Aktualisiere die Energie (Akkustandsbalken), die der Roboter hat
+     */
+    private void zeichneEnergie()
+    {
+        final int x=2;
+        final int y=1;
+        final int breite = 4;
+        final int hoehe = 46;
+        this.getImage().setColor(Color.GREEN);
+        this.getImage().fillRect(x, y, breite, hoehe);
+        int hoeheNeu = hoehe-(int)(Math.floor(hoehe*(energie/100.0)));
+        this.getImage().setColor(Color.RED);
+        this.getImage().fillRect(x, y, breite, hoeheNeu);
+        this.getImage().setColor(Color.BLACK);
+        this.getImage().drawRect(x, y, breite, hoehe);
+        this.getImage().drawRect(x, y, breite, hoehe/2);
+    }
+
+    // Meldungen und Warnungen
+    /**
+     * Gibt den uebergebenen String in einer Dialogbox auf dem Bildschirm aus
+     * @param text Der Text, der angezeit werden soll
+     * @param istWichtig bei true wird der Text "Achtung! Besonders wichtige Meldung:" in die Kopfzeile geschrieben, sonst nur der Text "Meldung!"
+     */
+    public void melde(String text, boolean istWichtig) {
+        String meldeText;
+        if (istWichtig) meldeText = "Achtung!\n";
+        else meldeText = "Meldung:\n";
+        Message m = new Message(meldeText+text);
+        getWorld().addObject(m, 7,6);
+        long z = System.currentTimeMillis();
+        while(System.currentTimeMillis()-z < 4000){
+            Greenfoot.delay(1);
+        }
+        getWorld().removeObject(m);
+    }
+
+    /**
+     * Gibt den uebergebenen String und eine Zahl in einer Dialogbox auf dem Bildschirm aus
+     * @param text Der Text, der angezeit werden soll
+     * @param z eine Zahl, die hinter dem Text text ausgegeben wird
+     */
+    private void melde(String text, int z) {
+        Message m = new Message(text+": "+z);
+        getWorld().addObject(m, 7,6);
+        long zz = System.currentTimeMillis();
+        while(System.currentTimeMillis()-zz < 4000){
+            Greenfoot.delay(1);
+        }
+        getWorld().removeObject(m);    
+    }
+
+    /**
+     * Gibt den uebergebenen String in einer Dialogbox als Warnung auf dem Bildschirm aus.
+     * Dadurch wird der uebergebene Actor actor von der Roboterwelt entfernt und diese neu gezeichnet.
+     * @param text Der Text, der angezeit werden soll
+     * @param actor Der Actor, der ggf. entfernt werden soll
+     */
+    public void warne(String text, Actor actor) {
+
+        Message m = new Message(text);
+        actor.getWorld().addObject(m, 7,6);
+        long z = System.currentTimeMillis();
+        while(System.currentTimeMillis()-z < 4000){
+            Greenfoot.delay(1);
+        }
+        actor.getWorld().removeObject(m);
+        
+            
+        Greenfoot.stop();    // nur falls Animation laeuft
+        World w = actor.getWorld();
+        if (actor != null) w.removeObject(actor); // Notbremse
+        Greenfoot.setWorld(new RoboterWelt());
+        // System.err.print("\u000C");
+        // System.err.flush();
+        System.err.close();
+        // System.out.close();
+        // System.out.println("Ablauf wurde vom Benutzer unterbrochen!");
+        // System.exit(0); //Das waere eigentlich sauber
+    }
+
+    // Systembedingte Routinen    
+    /**
+     * Wird aufgerufen, wenn der Roboter in die Welt gesetzt wird; 
+     * erweitert nach Vorschlag P.Henriksen 29.6.08
+     * @param world Die Welt in die ein Roboter gesetzt wurde
+     */
+    protected void addedToWorld(World world) {
+        // Roboter kann nicht auf eine Wand oder einen anderem Roboter gesetzt werden
+        Actor wand = getOneObjectAtOffset(0, 0, Wand.class);
+        Actor roboter = getOneObjectAtOffset(0, 0, Roboter.class);
+        if (wand != null || roboter != null) {
+            world.removeObject(this);
+        }
+    }
+
+    /* setLocation(x,y) und setRotation(x) koennen nicht verborgen werden, 
+     * weil sie schon in der Oberklasse Actor public sind. 
+     */
+
+    /**
+     * setLocation(x,y) fuer Roboter wird ueberschrieben, um nicht auf Wand oder
+     * anderen Roboter ziehen zu koennen!
+     * -- setzt den Roboter auf eine Kachel, deren Spalte x sowie Reihe y du 
+     * hier vorgibst. Die Nummerierung beginnt jeweils bei 0 !!) 
+     * @param x die x-Koordinate
+     * @param y die y-Koordinate
+     */
+    public void setLocation(int x, int y) {
+        boolean schwerkraft = ((RoboterWelt) getWorld()).getSchwerkraft();
+        if( (!((x==getX() && y==getY()) || (Math.abs(x-getX())+Math.abs(y-getY())<=1))) || (y<getY() && schwerkraft && !istAufGegenstand("Aufzug"))) {   // Verhindern des Verschiebens des Roboters
+            warne("Ich bin ein Roboter. Ich kann nicht fliegen.",this);
+        }
+        else {
+            List wand = getWorld().getObjectsAt(x, y, Wand.class);
+            List roboter = getWorld().getObjectsAt(x, y, Roboter.class);
+            Gegenstand g = (Gegenstand)this.getOneObjectAtOffset(0, 0, Gegenstand.class);
+            if (g!= null && !g.getName().equals("Aufzug")) { g= null;}
+
+            int[][] map = ((RoboterWelt) getWorld()).getMap();
+            roboter.remove(this); // Man selbst darf schon da stehen.
+            if (wand.isEmpty() && roboter.isEmpty()) {
+                if(g!=null && x==getX()) {g.setLocation(x,y); }
+                super.setLocation(x, y);
+
+            }
+            else warne ("Ich kann nicht an diesen Ort. Da ist kein Platz fuer mich!",this);
+        }
+    }
+
+    /**
+     * setRotation(x) fuer Roboter wird ueberschrieben, damit nur vier Rotationsrichtungen moeglich sind!
+     * @param x die Richtung (0=Osten, 90=Sueden, 180=Westen, 270=Norden)
+     */
+    public void setRotation(int x) {
+        if (x==0 || x==90 || x==180 || x==270) super.setRotation(x);
+        this.zeichneRobotImage();
+    }
+
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/Schalter.java

@@ -0,0 +1,107 @@
+import greenfoot.*;
+import java.util.*;
+
+/**
+ * Die Klasse Schalter ist eine Hilfsklasse für die Schlösser und Schalthebel 
+ * Sie hat zwei zweidimensionale Arrays, die für den Schalterzustand on bzw. off
+ * festlegen, wie ein Bereich der Welt aussehen soll. startx und starty speichern
+ * die linke obere Ecke dieses Bereichs.
+ */
+
+public class Schalter
+{
+    RoboterWelt   world;
+    private boolean an;
+    private int startx;
+    private int starty;
+    private int[][] on;
+    private int[][] off;
+
+    /** Der Konstruktor erstellt einen neuen Schalter
+     * @param w Die Welt, die manipuliert werden soll
+     */
+    public Schalter(World w) {
+        super();
+        an = true;
+        startx = 0;
+        starty = 0;
+        on = null;
+        off = null;
+        world = (RoboterWelt) w;
+    }
+
+    /** Die Methode setze verändert die Welt entsprechend den Vorgaben
+     * von backg. Dabei werden alle Objekte in diesem Bereich entfernt 
+     * (außer den Robotern) und gegen neue Objekte ausgetauscht.
+     * @param backg Zweidimensionales Array, das die neuen Actors für den Bereich festlegt.
+     */
+
+    private void setze(int[][] backg) {
+
+        for(int x=0; x<backg[0].length; x++) {
+            for(int y=0; y<backg.length; y++) {
+                if (backg[y][x]>=0 && (startx+x>0) && (startx+x<world.getWidth()-1) &&
+                (starty+y>1) && (starty+y<world.getHeight()-1)) {
+                    List al = world.getObjectsAt(x+startx,y+starty, null);
+                    for (int i = 0; i< al.size(); i++) {
+                        Actor da = (Actor) (al.get(i));
+                        if (! (da instanceof Roboter))  world.removeObject(da);
+                    }
+                    
+                    if(backg[y][x]>=0 && backg[y][x] <10) {
+                        world.changeBackground(backg[y][x], x, y);
+                    }
+                    Actor a = ((RoboterWelt) world).generateActor(backg[y][x]);
+                    if (backg[y][x] == 11 || backg[y][x]==12 || backg[y][x]==17 || backg[y][x]==22 || backg[y][x]==23) {
+                      ((Wand) a).setSchalter(this);
+                    }  
+                    if (backg[y][x] == 31) {
+                      ((Gegenstand) a).setSchalter(this);
+                    }  
+                    if (a!= null) world.addObject(a,x+startx,y+starty);
+                }
+            }
+        }
+    }
+
+    /** Setzt den Schalterzustand auf on
+     */  
+    public void anschalten() {
+        an = true;
+        if (on != null) setze(on);
+    }
+
+    /** Setzt den Schalterzustand auf off
+     */  
+
+    public void ausschalten() {
+        an = false;
+        if (off != null) setze(off);
+    }
+
+    /** Schaltet den Schalter um, d.h. von on auf off oder umgekehrt
+     */
+    public void umschalten() {
+        if (an) ausschalten(); else anschalten();
+    }
+
+    /** Legt fest, wie der Schalter die Welt verändern soll.
+     * @param x Koordinate der linke oberen Ecke des zu verändernden Bereichs
+     * @param y Koordinate der linke oberen Ecke des zu verändernden Bereichs
+     * @param on Zweidimensionales Array zu Festlegung, wie der Bereich bei angeschaltetem Schalter ausssehen soll
+     * @param off Zweidimensionales Array zu Festlegung, wie der Bereich bei ausgeschaltetem Schalter ausssehen soll
+     */
+    public void setPosition(int x, int y, int[][] on, int[][] off) {
+        startx = x;
+        starty = y;
+        this.on = on;
+        this.off = off;
+    }
+
+    /** Liefert den Schalterzustand
+     * @return true, wenn der Schalter an ist, sonst false
+     */
+    public boolean getAn() {
+        return an;
+    }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/Wand.java

@@ -0,0 +1,116 @@
+import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
+import java.util.*;
+
+/**
+ * Die Klasse Wand fast alle Actors zusammen, durch die der Roboter nicht hindurchlaufen kann.
+ * Dazu gehören neben den normalen Wänden auch Steine, Türen (vertikal/horizontal) usw.
+ */
+  
+public class Wand extends Actor
+{
+  private int typ;
+  private static String[] typen = {"Wand","Tuer","Tuer","Schalter","Schalter","Stromquelle","Stromquelle","Stromquelle","Stromquelle","Schloss","Stein","Steine","Schalter","Schalter"};
+  private String[] bilder = {"Wand","Tuer2","Tuer1","SchalterEin","SchalterAus","Stromquelle1","Stromquelle2","Stromquelle3","Stromquelle4","Schloss","Stein","Steine","Rufknopf","RufknopfAus"};
+  private Schalter schalter;    
+    
+  /** Erzeugt eine neue Wand vom angegeben Typ
+    * @param name Name des Typs ("Wand","Tuer2","Tuer1","SchalterEin","SchalterAus","Stromquelle1","Stromquelle2","Stromquelle3","Stromquelle4","Schloss","Stein","Steine","Rufknopf","RufknopfAus")
+    */
+  
+  public Wand(String name) {
+    super();
+    this.typ = 0;
+    
+    for(int i = 0; i < bilder.length; i++) {
+      if (name.equals(bilder[i])) {
+        this.typ = i;
+      }
+    }
+    this.setImage("images/"+bilder[typ]+".png");
+    schalter = null;
+  }
+  
+  /** Erzeugt eine neue Standardwand
+    */
+    
+  public Wand() {
+    super();
+    this.typ = 0;
+    this.setImage("images/"+bilder[typ]+".png");
+    schalter = null;
+  }
+  
+  /** untersucht, ob name eine korrekte Bezeichnug für einen Wandtyp ist
+     * @return erg true, wenn name korrekt ist
+     */
+    public static boolean istWandtyp(String name) {
+        boolean erg = false;
+        for(int i = 0; i < typen.length; i++) {
+            if (name.equals(typen[i])) {
+                erg = true;
+            }
+        }
+        return erg;
+    }
+  
+  /** Liefert den Typ der Wand 
+  * @return Typname (Wand, Tuer, Stromquelle, Schalter, Schloss, Stein, Steine)
+  */
+  public String getName() {
+    return this.typen[typ];
+  }
+  
+  /** Liefert einen mit diesem Objekt verbunden Schalter
+    * @return Schalter, wenn vorhanden, sonst null
+  */
+  public Schalter getSchalter() {
+    return this.schalter;
+  }
+  
+  /** Verbindet dieses Objekt mit einem Schalter, der
+  * die Welt verändern kann.
+  * @param s Schalterobjekt
+  */
+  public void setSchalter(Schalter s) {
+    this.schalter = s;
+  }
+
+  // Systembedingte Routinen    
+  /**
+    * Wird aufgerufen, wenn der Roboter in die Welt gesetzt wird; 
+    * erweitert nach Vorschlag P.Henriksen 29.6.08
+    */
+  protected void addedToWorld(World world) {
+    // Roboter kann nicht auf eine Wand oder einen anderem Roboter gesetzt werden
+    Actor wand = getOneObjectAtOffset(0, 0, Wand.class);
+    Actor roboter = getOneObjectAtOffset(0, 0, Roboter.class);
+    if (wand != null || roboter != null) {
+      world.removeObject(this);
+    }
+  }
+
+  /**
+   * setLocation(x,y) fuer Roboter wird ueberschrieben, um nicht auf Wand oder
+   * anderen Roboter ziehen zu koennen!
+   * -- setzt den Roboter auf eine Kachel, deren Spalte x sowie Reihe y du 
+   * hier vorgibst. Die Nummerierung beginnt jeweils bei 0 !!) 
+   */
+  public void setLocation(int x, int y) {
+    List wand = getWorld().getObjectsAt(x, y, null);
+    if (wand.isEmpty()) {
+      super.setLocation(x, y);
+    }
+  }
+   
+  /* setLocation(x,y) und setRotation(x) koennen nicht verborgen werden, 
+   * weil sie schon in der Oberklasse Actor public sind. 
+   */
+  
+  /**
+   * setRotation(x) fuer Roboter wird verhindert! 
+   * Es ist unnoetig, da Roboter sich nur in vier Richtungen drehen koennen!
+   */
+  public void setRotation(int x) {
+    // nichts machen!!
+  }
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/Roboter.html

@@ -0,0 +1,778 @@
+<!DOCTYPE HTML>
+<!-- NewPage -->
+<html lang="de">
+<head>
+<!-- Generated by javadoc (11.0.2) on Sat Nov 13 18:43:45 CET 2021 -->
+<title>Roboter</title>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="dc.created" content="2021-11-13">
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+<script type="text/javascript" src="script.js"></script>
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Roboter";
+        }
+    }
+    catch(err) {
+    }
+//-->
+var data = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10,"i19":10,"i20":10,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":10,"i27":10};
+var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
+var altColor = "altColor";
+var rowColor = "rowColor";
+var tableTab = "tableTab";
+var activeTableTab = "activeTableTab";
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<!-- ======== START OF CLASS DATA ======== -->
+<main role="main">
+<div class="header">
+<h2 title="Class Roboter" class="title">Class Roboter</h2>
+</div>
+<div class="contentContainer">
+<ul class="inheritance">
+<li>java.lang.Object</li>
+<li>
+<ul class="inheritance">
+<li>greenfoot.Actor</li>
+<li>
+<ul class="inheritance">
+<li>Roboter</li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+<div class="description">
+<ul class="blockList">
+<li class="blockList">
+<hr>
+<pre>public class <span class="typeNameLabel">Roboter</span>
+extends greenfoot.Actor</pre>
+<div class="block">Diese Klasse ist die Oberklasse fuer die Roboter "Robita", "Robson" und "Robby". 
+ Programme sollen nur in den Unterklassen 
+ implementiert werden, da diese Klasse fuer Java-Beginner sehr komplex ist.
+ Ein Roboter kann sich felderweise in die vier Himmelsrichtungen im Szenario bewegen. 
+ Ueber Sensoren kann er Informationen ueber seine Umwelt erhalten.</div>
+</li>
+</ul>
+</div>
+<div class="summary">
+<ul class="blockList">
+<li class="blockList">
+<!-- ======== CONSTRUCTOR SUMMARY ======== -->
+<section role="region">
+<ul class="blockList">
+<li class="blockList"><a id="constructor.summary">
+<!--   -->
+</a>
+<h3>Constructor Summary</h3>
+<table class="memberSummary">
+<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Constructor</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tr class="altColor">
+<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E()">Roboter</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Ein Objekt der Klasse Roboter wird exempliert bzw. instanziert.</div>
+</td>
+</tr>
+</table>
+</li>
+</ul>
+</section>
+<!-- ========== METHOD SUMMARY =========== -->
+<section role="region">
+<ul class="blockList">
+<li class="blockList"><a id="method.summary">
+<!--   -->
+</a>
+<h3>Method Summary</h3>
+<table class="memberSummary">
+<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
+<tr>
+<th class="colFirst" scope="col">Modifier and Type</th>
+<th class="colSecond" scope="col">Method</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tr id="i0" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ablegen(java.lang.String)">ablegen</a></span>&#8203;(java.lang.String&nbsp;name)</code></th>
+<td class="colLast">
+<div class="block">Der Roboter legt einen Gegenstand aus seinem Vorrat auf dem Feld ab.</div>
+</td>
+</tr>
+<tr id="i1" class="rowColor">
+<td class="colFirst"><code>protected void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addedToWorld(greenfoot.World)">addedToWorld</a></span>&#8203;(greenfoot.World&nbsp;world)</code></th>
+<td class="colLast">
+<div class="block">Wird aufgerufen, wenn der Roboter in die Welt gesetzt wird; 
+ erweitert nach Vorschlag P.Henriksen 29.6.08</div>
+</td>
+</tr>
+<tr id="i2" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#aufnehmen()">aufnehmen</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Roboter nimmt einen Gegenstand, der sich auf seinem Feld befindet in seinen Vorrat auf.</div>
+</td>
+</tr>
+<tr id="i3" class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#benutze(java.lang.String)">benutze</a></span>&#8203;(java.lang.String&nbsp;name)</code></th>
+<td class="colLast">
+<div class="block">Benutzt den angegebenen Gegenstand.</div>
+</td>
+</tr>
+<tr id="i4" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#dreheLinks()">dreheLinks</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Roboter dreht sich um 90 Grad nach links (aus der Sicht des Roboters).</div>
+</td>
+</tr>
+<tr id="i5" class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#dreheRechts()">dreheRechts</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Roboter dreht sich um 90 Grad nach rechts (aus der Sicht des Roboters).</div>
+</td>
+</tr>
+<tr id="i6" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#dreheUm()">dreheUm</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Roboter dreht sich um 180 Grad nach rechts (aus der Sicht des Roboters).</div>
+</td>
+</tr>
+<tr id="i7" class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#einsVor()">einsVor</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Roboter geht einen Schritt in die Pfeilrichtung.</div>
+</td>
+</tr>
+<tr id="i8" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#gehilfeEinsetzen(Roboter)">gehilfeEinsetzen</a></span>&#8203;(<a href="Roboter.html" title="class in &lt;Unnamed&gt;">Roboter</a>&nbsp;r)</code></th>
+<td class="colLast">
+<div class="block">Diese Methode setzt einen Roboter vor den Roboter, der diese Methode aufruft.</div>
+</td>
+</tr>
+<tr id="i9" class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getAnzahl()">getAnzahl</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Gibt die Anzahl der Gegenstaende, die Roboter traegt, zurueck.</div>
+</td>
+</tr>
+<tr id="i10" class="altColor">
+<td class="colFirst"><code>int</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getAnzahl(java.lang.String)">getAnzahl</a></span>&#8203;(java.lang.String&nbsp;name)</code></th>
+<td class="colLast">
+<div class="block">Gibt die Anzahl der Gegenstaende einer bestimmten Art zurueck.</div>
+</td>
+</tr>
+<tr id="i11" class="rowColor">
+<td class="colFirst"><code>int</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getEnergie()">getEnergie</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Gibt die Restenergie des Roboters zurück</div>
+</td>
+</tr>
+<tr id="i12" class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#hatGegenstand(java.lang.String)">hatGegenstand</a></span>&#8203;(java.lang.String&nbsp;name)</code></th>
+<td class="colLast">
+<div class="block">Gibt zurueck, ob der Roboter mindestens einen Gegenstand der angegeben Art besitzt.</div>
+</td>
+</tr>
+<tr id="i13" class="rowColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istAufGegenstand()">istAufGegenstand</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Liefert genau dann true, wenn auf der Kachel, auf der sich der
+ aufgerufene Roboter gerade befindet, ein beliebiger Gegenstand befindet.</div>
+</td>
+</tr>
+<tr id="i14" class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istAufGegenstand(java.lang.String)">istAufGegenstand</a></span>&#8203;(java.lang.String&nbsp;name)</code></th>
+<td class="colLast">
+<div class="block">Liefert genau dann true, wenn auf der Kachel, auf der sich der
+ aufgerufene Roboter gerade befindet, ein Gegenstand mit dem angegebnen Namen befindet.</div>
+</td>
+</tr>
+<tr id="i15" class="rowColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istEnergieLeer()">istEnergieLeer</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Gibt zurueck, ob die Energie des Roboters verbraucht ist.</div>
+</td>
+</tr>
+<tr id="i16" class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istInventarLeer()">istInventarLeer</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Liefert genau dann true, wenn der aufgerufene Roboter keinen Gegenstand bei sich hat.</div>
+</td>
+</tr>
+<tr id="i17" class="rowColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istVorne(java.lang.String)">istVorne</a></span>&#8203;(java.lang.String&nbsp;name)</code></th>
+<td class="colLast">
+<div class="block">Liefert genau dann true, wenn sich vor dem Roboter ein Gegenstand mit dem angegebnen Namen befindet.</div>
+</td>
+</tr>
+<tr id="i18" class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istVorneFrei()">istVorneFrei</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Sensor ueberprueft, ob vor dem Roboter Hindernisse stehen oder nicht</div>
+</td>
+</tr>
+<tr id="i19" class="rowColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istWandLinks()">istWandLinks</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Sensor ueberprueft, ob sich links der Laufrichtung eine Wand befindet.</div>
+</td>
+</tr>
+<tr id="i20" class="altColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istWandRechts()">istWandRechts</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Sensor ueberprueft, ob sich rechts der Laufrichtung eine Wand befindet.</div>
+</td>
+</tr>
+<tr id="i21" class="rowColor">
+<td class="colFirst"><code>boolean</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#istWandVorne()">istWandVorne</a></span>()</code></th>
+<td class="colLast">
+<div class="block">Der Sensor ueberprueft, ob sich in Laufrichtung des Roboters eine Wand befindet.</div>
+</td>
+</tr>
+<tr id="i22" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#melde(java.lang.String,boolean)">melde</a></span>&#8203;(java.lang.String&nbsp;text,
+     boolean&nbsp;istWichtig)</code></th>
+<td class="colLast">
+<div class="block">Gibt den uebergebenen String in einer Dialogbox auf dem Bildschirm aus</div>
+</td>
+</tr>
+<tr id="i23" class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setAnzahlVonGegenstand(java.lang.String,int)">setAnzahlVonGegenstand</a></span>&#8203;(java.lang.String&nbsp;name,
+                      int&nbsp;anzahl)</code></th>
+<td class="colLast">
+<div class="block">Gibt dem Roboter eine bestimmte Anzahl von Gegenstaenden einer Art</div>
+</td>
+</tr>
+<tr id="i24" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setLocation(int,int)">setLocation</a></span>&#8203;(int&nbsp;x,
+           int&nbsp;y)</code></th>
+<td class="colLast">
+<div class="block">setLocation(x,y) fuer Roboter wird ueberschrieben, um nicht auf Wand oder
+ anderen Roboter ziehen zu koennen!</div>
+</td>
+</tr>
+<tr id="i25" class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#setRotation(int)">setRotation</a></span>&#8203;(int&nbsp;x)</code></th>
+<td class="colLast">
+<div class="block">setRotation(x) fuer Roboter wird ueberschrieben, damit nur vier Rotationsrichtungen moeglich sind!</div>
+</td>
+</tr>
+<tr id="i26" class="altColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#verbraucheEnergie(int)">verbraucheEnergie</a></span>&#8203;(int&nbsp;verlust)</code></th>
+<td class="colLast">
+<div class="block">Reduziert die Restenergie des Roboters um den angegebenen Wert.</div>
+</td>
+</tr>
+<tr id="i27" class="rowColor">
+<td class="colFirst"><code>void</code></td>
+<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#warne(java.lang.String,greenfoot.Actor)">warne</a></span>&#8203;(java.lang.String&nbsp;text,
+     greenfoot.Actor&nbsp;actor)</code></th>
+<td class="colLast">
+<div class="block">Gibt den uebergebenen String in einer Dialogbox als Warnung auf dem Bildschirm aus.</div>
+</td>
+</tr>
+</table>
+<ul class="blockList">
+<li class="blockList"><a id="methods.inherited.from.class.greenfoot.Actor">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;greenfoot.Actor</h3>
+<code>act, getImage, getIntersectingObjects, getNeighbours, getObjectsAtOffset, getObjectsInRange, getOneIntersectingObject, getOneObjectAtOffset, getRotation, getWorld, getWorldOfType, getX, getY, intersects, isAtEdge, isTouching, move, removeTouching, setImage, setImage, turn, turnTowards</code></li>
+</ul>
+<ul class="blockList">
+<li class="blockList"><a id="methods.inherited.from.class.java.lang.Object">
+<!--   -->
+</a>
+<h3>Methods inherited from class&nbsp;java.lang.Object</h3>
+<code>clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
+</ul>
+</li>
+</ul>
+</section>
+</li>
+</ul>
+</div>
+<div class="details">
+<ul class="blockList">
+<li class="blockList">
+<!-- ========= CONSTRUCTOR DETAIL ======== -->
+<section role="region">
+<ul class="blockList">
+<li class="blockList"><a id="constructor.detail">
+<!--   -->
+</a>
+<h3>Constructor Detail</h3>
+<a id="&lt;init&gt;()">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>Roboter</h4>
+<pre>public&nbsp;Roboter()</pre>
+<div class="block">Ein Objekt der Klasse Roboter wird exempliert bzw. instanziert.</div>
+</li>
+</ul>
+</li>
+</ul>
+</section>
+<!-- ============ METHOD DETAIL ========== -->
+<section role="region">
+<ul class="blockList">
+<li class="blockList"><a id="method.detail">
+<!--   -->
+</a>
+<h3>Method Detail</h3>
+<a id="getAnzahl()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getAnzahl</h4>
+<pre class="methodSignature">public&nbsp;int&nbsp;getAnzahl()</pre>
+<div class="block">Gibt die Anzahl der Gegenstaende, die Roboter traegt, zurueck.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>Anzahl der Gegenstaende</dd>
+</dl>
+</li>
+</ul>
+<a id="getAnzahl(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getAnzahl</h4>
+<pre class="methodSignature">public&nbsp;int&nbsp;getAnzahl&#8203;(java.lang.String&nbsp;name)</pre>
+<div class="block">Gibt die Anzahl der Gegenstaende einer bestimmten Art zurueck.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Art der Gegenstands (z.B. "Schluessel")</dd>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>Anzahl der Gegenstaende</dd>
+</dl>
+</li>
+</ul>
+<a id="getEnergie()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getEnergie</h4>
+<pre class="methodSignature">public&nbsp;int&nbsp;getEnergie()</pre>
+<div class="block">Gibt die Restenergie des Roboters zurück</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>Energiereserve (0-100)</dd>
+</dl>
+</li>
+</ul>
+<a id="verbraucheEnergie(int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>verbraucheEnergie</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;verbraucheEnergie&#8203;(int&nbsp;verlust)</pre>
+<div class="block">Reduziert die Restenergie des Roboters um den angegebenen Wert.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>verlust</code> - Anzahl der verbrauchten Energiepunkte</dd>
+</dl>
+</li>
+</ul>
+<a id="istEnergieLeer()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istEnergieLeer</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istEnergieLeer()</pre>
+<div class="block">Gibt zurueck, ob die Energie des Roboters verbraucht ist.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn Restenergie =0, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="einsVor()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>einsVor</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;einsVor()</pre>
+<div class="block">Der Roboter geht einen Schritt in die Pfeilrichtung.
+ Das macht er nur, wenn sich keine Wand vor ihm befindet oder
+ er nicht an der Grenze der Welt zur Wand blickt.</div>
+</li>
+</ul>
+<a id="dreheRechts()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>dreheRechts</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;dreheRechts()</pre>
+<div class="block">Der Roboter dreht sich um 90 Grad nach rechts (aus der Sicht des Roboters).</div>
+</li>
+</ul>
+<a id="dreheUm()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>dreheUm</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;dreheUm()</pre>
+<div class="block">Der Roboter dreht sich um 180 Grad nach rechts (aus der Sicht des Roboters).</div>
+</li>
+</ul>
+<a id="dreheLinks()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>dreheLinks</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;dreheLinks()</pre>
+<div class="block">Der Roboter dreht sich um 90 Grad nach links (aus der Sicht des Roboters).</div>
+</li>
+</ul>
+<a id="hatGegenstand(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>hatGegenstand</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;hatGegenstand&#8203;(java.lang.String&nbsp;name)</pre>
+<div class="block">Gibt zurueck, ob der Roboter mindestens einen Gegenstand der angegeben Art besitzt.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Art des gesuchten Gegenstands</dd>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn der Roboter einen derartigen Gegenstand hat, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="setAnzahlVonGegenstand(java.lang.String,int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setAnzahlVonGegenstand</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;setAnzahlVonGegenstand&#8203;(java.lang.String&nbsp;name,
+                                   int&nbsp;anzahl)</pre>
+<div class="block">Gibt dem Roboter eine bestimmte Anzahl von Gegenstaenden einer Art</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Art des Gegenstands</dd>
+</dl>
+</li>
+</ul>
+<a id="benutze(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>benutze</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;benutze&#8203;(java.lang.String&nbsp;name)</pre>
+<div class="block">Benutzt den angegebenen Gegenstand. Es koennen nur Schluessel, Schalter, Bombe, Feuerloescher und Akku benutzt werden.
+ Dabei kann ein Schluessel nur direkt vor einem Schloss benutzt werden. Eine Bombe sprengt einen Bereich frei. Der Feuerloescher 
+ kann ein direkt vor dem Roboter befindliches Feuer loeschen. Der Akku erhoeht die Restenergie des Roboters.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Art des zu benutzenden Gegenstands ("Schluessel", "Schalter", "Bombe", "Feuerloescher", "Akku")</dd>
+</dl>
+</li>
+</ul>
+<a id="istAufGegenstand()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istAufGegenstand</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istAufGegenstand()</pre>
+<div class="block">Liefert genau dann true, wenn auf der Kachel, auf der sich der
+ aufgerufene Roboter gerade befindet, ein beliebiger Gegenstand befindet.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn der Roboter auf einem Gegenstand steht, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="istAufGegenstand(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istAufGegenstand</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istAufGegenstand&#8203;(java.lang.String&nbsp;name)</pre>
+<div class="block">Liefert genau dann true, wenn auf der Kachel, auf der sich der
+ aufgerufene Roboter gerade befindet, ein Gegenstand mit dem angegebnen Namen befindet.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Einer der Gegenstaende ("Schluessel", "Schalter", "Bombe", "Feuerloescher", "Brennstab", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer", "Aufzug")</dd>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn der Roboter auf einem Gegenstand steht, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="istInventarLeer()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istInventarLeer</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istInventarLeer()</pre>
+<div class="block">Liefert genau dann true, wenn der aufgerufene Roboter keinen Gegenstand bei sich hat.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn der Roboter keinen Gegenstand mit sich traegt, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="ablegen(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>ablegen</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;ablegen&#8203;(java.lang.String&nbsp;name)</pre>
+<div class="block">Der Roboter legt einen Gegenstand aus seinem Vorrat auf dem Feld ab.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Einer der Gegenstaende ("Schluessel", "Schalter", "Bombe", "Brennstab", "Feuerloescher", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer")</dd>
+</dl>
+</li>
+</ul>
+<a id="aufnehmen()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>aufnehmen</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;aufnehmen()</pre>
+<div class="block">Der Roboter nimmt einen Gegenstand, der sich auf seinem Feld befindet in seinen Vorrat auf.
+ Falls er nicht auf einem Gegenstand steht, gibt er eine Warnung aus.
+ Roboter haben nur eine begrenzte Kapazitaet. Sie koennen maximal 99 Gegenstaende mit sich tragen.
+ Falls er einen 100. Gegenstand aufnehmen moechte, wird auch eine entsprechende Warnung ausgegeben.</div>
+</li>
+</ul>
+<a id="gehilfeEinsetzen(Roboter)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>gehilfeEinsetzen</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;gehilfeEinsetzen&#8203;(<a href="Roboter.html" title="class in &lt;Unnamed&gt;">Roboter</a>&nbsp;r)</pre>
+<div class="block">Diese Methode setzt einen Roboter vor den Roboter, der diese Methode aufruft.
+ Ist vor ihm kein Platz, wird eine Warnung ausgegeben.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>r</code> - der Hilfsroboter, der eingesetzt werden soll</dd>
+</dl>
+</li>
+</ul>
+<a id="istVorneFrei()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istVorneFrei</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istVorneFrei()</pre>
+<div class="block">Der Sensor ueberprueft, ob vor dem Roboter Hindernisse stehen oder nicht</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn vor dem Roboter frei ist, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="istVorne(java.lang.String)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istVorne</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istVorne&#8203;(java.lang.String&nbsp;name)</pre>
+<div class="block">Liefert genau dann true, wenn sich vor dem Roboter ein Gegenstand mit dem angegebnen Namen befindet.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>name</code> - Einer der Gegenstaende ("Schluessel", "Schalter", "Schloss", "Bombe", "Feuerloescher", "Akku", "Schraube", "Kontaktplatte", "Oelfleck", "Portal", "Strom", "Feuer", "Aufzug")</dd>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn der Roboter vor dem Gegenstand mit dem Namen name steht, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="istWandVorne()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istWandVorne</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istWandVorne()</pre>
+<div class="block">Der Sensor ueberprueft, ob sich in Laufrichtung des Roboters eine Wand befindet.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn der Roboter vor einer Wand steht, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="istWandRechts()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istWandRechts</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istWandRechts()</pre>
+<div class="block">Der Sensor ueberprueft, ob sich rechts der Laufrichtung eine Wand befindet.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn sich rechts von dem Roboter eine Wand befindet, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="istWandLinks()">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>istWandLinks</h4>
+<pre class="methodSignature">public&nbsp;boolean&nbsp;istWandLinks()</pre>
+<div class="block">Der Sensor ueberprueft, ob sich links der Laufrichtung eine Wand befindet.</div>
+<dl>
+<dt><span class="returnLabel">Returns:</span></dt>
+<dd>true, wenn sich links von dem Roboter eine Wand befindet, sonst false</dd>
+</dl>
+</li>
+</ul>
+<a id="melde(java.lang.String,boolean)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>melde</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;melde&#8203;(java.lang.String&nbsp;text,
+                  boolean&nbsp;istWichtig)</pre>
+<div class="block">Gibt den uebergebenen String in einer Dialogbox auf dem Bildschirm aus</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>text</code> - Der Text, der angezeit werden soll</dd>
+<dd><code>istWichtig</code> - bei true wird der Text "Achtung! Besonders wichtige Meldung:" in die Kopfzeile geschrieben, sonst nur der Text "Meldung!"</dd>
+</dl>
+</li>
+</ul>
+<a id="warne(java.lang.String,greenfoot.Actor)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>warne</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;warne&#8203;(java.lang.String&nbsp;text,
+                  greenfoot.Actor&nbsp;actor)</pre>
+<div class="block">Gibt den uebergebenen String in einer Dialogbox als Warnung auf dem Bildschirm aus.
+ Dadurch wird der uebergebene Actor actor von der Roboterwelt entfernt und diese neu gezeichnet.</div>
+<dl>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>text</code> - Der Text, der angezeit werden soll</dd>
+<dd><code>actor</code> - Der Actor, der ggf. entfernt werden soll</dd>
+</dl>
+</li>
+</ul>
+<a id="addedToWorld(greenfoot.World)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>addedToWorld</h4>
+<pre class="methodSignature">protected&nbsp;void&nbsp;addedToWorld&#8203;(greenfoot.World&nbsp;world)</pre>
+<div class="block">Wird aufgerufen, wenn der Roboter in die Welt gesetzt wird; 
+ erweitert nach Vorschlag P.Henriksen 29.6.08</div>
+<dl>
+<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
+<dd><code>addedToWorld</code>&nbsp;in class&nbsp;<code>greenfoot.Actor</code></dd>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>world</code> - Die Welt in die ein Roboter gesetzt wurde</dd>
+</dl>
+</li>
+</ul>
+<a id="setLocation(int,int)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>setLocation</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;setLocation&#8203;(int&nbsp;x,
+                        int&nbsp;y)</pre>
+<div class="block">setLocation(x,y) fuer Roboter wird ueberschrieben, um nicht auf Wand oder
+ anderen Roboter ziehen zu koennen!
+ -- setzt den Roboter auf eine Kachel, deren Spalte x sowie Reihe y du 
+ hier vorgibst. Die Nummerierung beginnt jeweils bei 0 !!)</div>
+<dl>
+<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
+<dd><code>setLocation</code>&nbsp;in class&nbsp;<code>greenfoot.Actor</code></dd>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>x</code> - die x-Koordinate</dd>
+<dd><code>y</code> - die y-Koordinate</dd>
+</dl>
+</li>
+</ul>
+<a id="setRotation(int)">
+<!--   -->
+</a>
+<ul class="blockListLast">
+<li class="blockList">
+<h4>setRotation</h4>
+<pre class="methodSignature">public&nbsp;void&nbsp;setRotation&#8203;(int&nbsp;x)</pre>
+<div class="block">setRotation(x) fuer Roboter wird ueberschrieben, damit nur vier Rotationsrichtungen moeglich sind!</div>
+<dl>
+<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
+<dd><code>setRotation</code>&nbsp;in class&nbsp;<code>greenfoot.Actor</code></dd>
+<dt><span class="paramLabel">Parameters:</span></dt>
+<dd><code>x</code> - die Richtung (0=Osten, 90=Sueden, 180=Westen, 270=Norden)</dd>
+</dl>
+</li>
+</ul>
+</li>
+</ul>
+</section>
+</li>
+</ul>
+</div>
+</div>
+</main>
+<!-- ========= END OF CLASS DATA ========= -->
+</body>
+</html>

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/allclasses.html

@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<!-- NewPage -->
+<html lang="de">
+<head>
+<!-- Generated by javadoc (11.0.2) on Sat Nov 13 18:43:45 CET 2021 -->
+<title>All Classes</title>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="dc.created" content="2021-11-13">
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+<script type="text/javascript" src="script.js"></script>
+</head>
+<body>
+<h1 class="bar">All&nbsp;Classes</h1>
+<main role="main" class="indexContainer">
+<ul>
+<li><a href="Roboter.html" title="class in &lt;Unnamed&gt;">Roboter</a></li>
+</ul>
+</main>
+</body>
+</html>

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/constant-values.html

@@ -0,0 +1,35 @@
+<!DOCTYPE HTML>
+<!-- NewPage -->
+<html lang="de">
+<head>
+<!-- Generated by javadoc (11.0.2) on Sat Nov 13 18:43:45 CET 2021 -->
+<title>Constant Field Values</title>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="dc.created" content="2021-11-13">
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+<script type="text/javascript" src="script.js"></script>
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="Constant Field Values";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<main role="main">
+<div class="header">
+<h1 title="Constant Field Values" class="title">Constant Field Values</h1>
+<section role="region">
+<h2 title="Contents">Contents</h2>
+</section>
+</div>
+</main>
+</body>
+</html>

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/element-list

@@ -0,0 +1 @@
+unnamed package

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/index.html

@@ -0,0 +1,23 @@
+<!DOCTYPE HTML>
+<!-- NewPage -->
+<html lang="de">
+<head>
+<!-- Generated by javadoc (11.0.2) on Sat Nov 13 18:43:45 CET 2021 -->
+<title>Generated Documentation (Untitled)</title>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<script type="text/javascript">window.location.replace('Roboter.html')</script>
+<noscript>
+<meta http-equiv="Refresh" content="0;Roboter.html">
+</noscript>
+<link rel="canonical" href="Roboter.html">
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+</head>
+<body>
+<main role="main">
+<noscript>
+<p>JavaScript is disabled on your browser.</p>
+</noscript>
+<p><a href="Roboter.html">Roboter.html</a></p>
+</main>
+</body>
+</html>

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/logfile.txt

@@ -0,0 +1,42 @@
+Class documentation
+<---- javadoc command: ---->
+E:\Programme\Informatik\Greenfoot361\jdk\bin\javadoc.exe
+-author
+-version
+-nodeprecated
+-protected
+-Xdoclint:none
+-noindex
+-notree
+-nohelp
+-nonavbar
+-source
+11
+-classpath
+E:\Programme\Informatik\Greenfoot361\lib\extensions\greenfoot.jar;E:\Programme\Informatik\Greenfoot361\lib\bluejcore.jar;E:\Programme\Informatik\Greenfoot361\lib\bluejeditor.jar;E:\Programme\Informatik\Greenfoot361\lib\bluejext.jar;E:\Programme\Informatik\Greenfoot361\lib\junit-4.11.jar;E:\Programme\Informatik\Greenfoot361\lib\hamcrest-core-1.3.jar;E:\Programme\Informatik\Greenfoot361\lib\bluej.jar;E:\Programme\Informatik\Greenfoot361\lib\classgraph-4.2.6.jar;E:\Programme\Informatik\Greenfoot361\lib\diffutils-1.2.1.jar;E:\Programme\Informatik\Greenfoot361\lib\commons-logging-api-1.1.2.jar;E:\Programme\Informatik\Greenfoot361\lib\jl1.0.1.jar;E:\Programme\Informatik\Greenfoot361\lib\opencsv-2.3.jar;E:\Programme\Informatik\Greenfoot361\lib\xom-1.2.9.jar;E:\Programme\Informatik\Greenfoot361\lib\lang-stride.jar;E:\Programme\Informatik\Greenfoot361\lib\nsmenufx-2.1.4.jar;E:\Programme\Informatik\Greenfoot361\lib\richtextfx-fat-0.9.0.jar;E:\Programme\Informatik\Greenfoot361\lib\guava-17.0.jar;E:\Programme\Informatik\Greenfoot361\lib\httpclient-4.1.1.jar;E:\Programme\Informatik\Greenfoot361\lib\httpcore-4.1.jar;E:\Programme\Informatik\Greenfoot361\lib\httpmime-4.1.1.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.base.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.controls.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.fxml.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.graphics.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.media.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.properties.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.swing.jar;E:\Programme\Informatik\Greenfoot361\lib\javafx\lib\javafx.web.jar;F:\Informatik\Fortbildung ZPG IMP9\Greenfoot\OptischeTaeuschungUnterklasse V3 - Animation\jdom-1.1.3.jar;F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung
+-d
+F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc
+-encoding
+windows-1252
+-charset
+windows-1252
+F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\Roboter.java
+<---- end of javadoc command ---->
+Loading source file F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\Roboter.java...
+Constructing Javadoc information...
+warning: unknown enum constant Tag.Any
+  reason: class file for threadchecker.Tag not found
+warning: unknown enum constant Tag.Any
+warning: unknown enum constant Tag.Any
+warning: unknown enum constant Tag.Any
+Standard Doclet version 11.0.2
+Building tree for all the packages and classes...
+Generating F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc\Roboter.html...
+Generating F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc\package-summary.html...
+Generating F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc\constant-values.html...
+Building index for all the packages and classes...
+Building index for all classes...
+Generating F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc\allclasses.html...
+Generating F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc\allclasses.html...
+Generating F:\Informatik\Fortbildung Jahreskurs\jahreskurs_einfuehrung_programmierung\01_ReaktorRobot_GF361_20211111\4_loesungen\01_ReaktorRobot_GF361_Szenario_Loesung\doc\index.html...
+4 warnings

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/package-summary.html

@@ -0,0 +1,53 @@
+<!DOCTYPE HTML>
+<!-- NewPage -->
+<html lang="de">
+<head>
+<!-- Generated by javadoc (11.0.2) on Sat Nov 13 18:43:45 CET 2021 -->
+<title>&lt;Unnamed&gt;</title>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="dc.created" content="2021-11-13">
+<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
+<script type="text/javascript" src="script.js"></script>
+</head>
+<body>
+<script type="text/javascript"><!--
+    try {
+        if (location.href.indexOf('is-external=true') == -1) {
+            parent.document.title="<Unnamed>";
+        }
+    }
+    catch(err) {
+    }
+//-->
+</script>
+<noscript>
+<div>JavaScript is disabled on your browser.</div>
+</noscript>
+<main role="main">
+<div class="header">
+<h1 title="Package" class="title">Package&nbsp;&lt;Unnamed&gt;</h1>
+</div>
+<div class="contentContainer">
+<ul class="blockList">
+<li class="blockList">
+<table class="typeSummary">
+<caption><span>Class Summary</span><span class="tabEnd">&nbsp;</span></caption>
+<tr>
+<th class="colFirst" scope="col">Class</th>
+<th class="colLast" scope="col">Description</th>
+</tr>
+<tbody>
+<tr class="altColor">
+<th class="colFirst" scope="row"><a href="Roboter.html" title="class in &lt;Unnamed&gt;">Roboter</a></th>
+<td class="colLast">
+<div class="block">Diese Klasse ist die Oberklasse fuer die Roboter "Robita", "Robson" und "Robby".</div>
+</td>
+</tr>
+</tbody>
+</table>
+</li>
+</ul>
+</div>
+</main>
+</body>
+</html>

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/script.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+var moduleSearchIndex;
+var packageSearchIndex;
+var typeSearchIndex;
+var memberSearchIndex;
+var tagSearchIndex;
+function loadScripts(doc, tag) {
+    createElem(doc, tag, 'jquery/jszip/dist/jszip.js');
+    createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils.js');
+    if (window.navigator.userAgent.indexOf('MSIE ') > 0 || window.navigator.userAgent.indexOf('Trident/') > 0 ||
+            window.navigator.userAgent.indexOf('Edge/') > 0) {
+        createElem(doc, tag, 'jquery/jszip-utils/dist/jszip-utils-ie.js');
+    }
+    createElem(doc, tag, 'search.js');
+    
+    $.get(pathtoroot + "module-search-index.zip")
+            .done(function() {
+                JSZipUtils.getBinaryContent(pathtoroot + "module-search-index.zip", function(e, data) {
+                    var zip = new JSZip(data);
+                    zip.load(data);
+                    moduleSearchIndex = JSON.parse(zip.file("module-search-index.json").asText());
+                });
+            });
+    $.get(pathtoroot + "package-search-index.zip")
+            .done(function() {
+                JSZipUtils.getBinaryContent(pathtoroot + "package-search-index.zip", function(e, data) {
+                    var zip = new JSZip(data);
+                    zip.load(data);
+                    packageSearchIndex = JSON.parse(zip.file("package-search-index.json").asText());
+                });
+            });
+    $.get(pathtoroot + "type-search-index.zip")
+            .done(function() {
+                JSZipUtils.getBinaryContent(pathtoroot + "type-search-index.zip", function(e, data) {
+                    var zip = new JSZip(data);
+                    zip.load(data);
+                    typeSearchIndex = JSON.parse(zip.file("type-search-index.json").asText());
+                });
+            });
+    $.get(pathtoroot + "member-search-index.zip")
+            .done(function() {
+                JSZipUtils.getBinaryContent(pathtoroot + "member-search-index.zip", function(e, data) {
+                    var zip = new JSZip(data);
+                    zip.load(data);
+                    memberSearchIndex = JSON.parse(zip.file("member-search-index.json").asText());
+                });
+            });
+    $.get(pathtoroot + "tag-search-index.zip")
+            .done(function() {
+                JSZipUtils.getBinaryContent(pathtoroot + "tag-search-index.zip", function(e, data) {
+                    var zip = new JSZip(data);
+                    zip.load(data);
+                    tagSearchIndex = JSON.parse(zip.file("tag-search-index.json").asText());
+                });
+            });
+    if (!moduleSearchIndex) {
+        createElem(doc, tag, 'module-search-index.js');
+    }
+    if (!packageSearchIndex) {
+        createElem(doc, tag, 'package-search-index.js');
+    }
+    if (!typeSearchIndex) {
+        createElem(doc, tag, 'type-search-index.js');
+    }
+    if (!memberSearchIndex) {
+        createElem(doc, tag, 'member-search-index.js');
+    }
+    if (!tagSearchIndex) {
+        createElem(doc, tag, 'tag-search-index.js');
+    }
+    $(window).resize(function() {
+        $('.navPadding').css('padding-top', $('.fixedNav').css("height"));
+    });
+}
+
+function createElem(doc, tag, path) {
+    var script = doc.createElement(tag);
+    var scriptElement = doc.getElementsByTagName(tag)[0];
+    script.src = pathtoroot + path;
+    scriptElement.parentNode.insertBefore(script, scriptElement);
+}
+
+function show(type) {
+    count = 0;
+    for (var key in data) {
+        var row = document.getElementById(key);
+        if ((data[key] &  type) !== 0) {
+            row.style.display = '';
+            row.className = (count++ % 2) ? rowColor : altColor;
+        }
+        else
+            row.style.display = 'none';
+    }
+    updateTabs(type);
+}
+
+function updateTabs(type) {
+    for (var value in tabs) {
+        var sNode = document.getElementById(tabs[value][0]);
+        var spanNode = sNode.firstChild;
+        if (value == type) {
+            sNode.className = activeTableTab;
+            spanNode.innerHTML = tabs[value][1];
+        }
+        else {
+            sNode.className = tableTab;
+            spanNode.innerHTML = "<a href=\"javascript:show("+ value + ");\">" + tabs[value][1] + "</a>";
+        }
+    }
+}
+
+function updateModuleFrame(pFrame, cFrame) {
+    top.packageFrame.location = pFrame;
+    top.classFrame.location = cFrame;
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/doc/stylesheet.css

@@ -0,0 +1,906 @@
+/* 
+ * Javadoc style sheet
+ */
+
+@import url('resources/fonts/dejavu.css');
+
+/*
+ * Styles for individual HTML elements.
+ *
+ * These are styles that are specific to individual HTML elements. Changing them affects the style of a particular
+ * HTML element throughout the page.
+ */
+
+body {
+    background-color:#ffffff;
+    color:#353833;
+    font-family:'DejaVu Sans', Arial, Helvetica, sans-serif;
+    font-size:14px;
+    margin:0;
+    padding:0;
+    height:100%;
+    width:100%;
+}
+iframe {
+    margin:0;
+    padding:0;
+    height:100%;
+    width:100%;
+    overflow-y:scroll;
+    border:none;
+}
+a:link, a:visited {
+    text-decoration:none;
+    color:#4A6782;
+}
+a[href]:hover, a[href]:focus {
+    text-decoration:none;
+    color:#bb7a2a;
+}
+a[name] {
+    color:#353833;
+}
+a[name]:before, a[name]:target, a[id]:before, a[id]:target {
+    content:"";
+    display:inline-block;
+    position:relative;
+    padding-top:129px;
+    margin-top:-129px;
+}
+pre {
+    font-family:'DejaVu Sans Mono', monospace;
+    font-size:14px;
+}
+h1 {
+    font-size:20px;
+}
+h2 {
+    font-size:18px;
+}
+h3 {
+    font-size:16px;
+    font-style:italic;
+}
+h4 {
+    font-size:13px;
+}
+h5 {
+    font-size:12px;
+}
+h6 {
+    font-size:11px;
+}
+ul {
+    list-style-type:disc;
+}
+code, tt {
+    font-family:'DejaVu Sans Mono', monospace;
+    font-size:14px;
+    padding-top:4px;
+    margin-top:8px;
+    line-height:1.4em;
+}
+dt code {
+    font-family:'DejaVu Sans Mono', monospace;
+    font-size:14px;
+    padding-top:4px;
+}
+table tr td dt code {
+    font-family:'DejaVu Sans Mono', monospace;
+    font-size:14px;
+    vertical-align:top;
+    padding-top:4px;
+}
+sup {
+    font-size:8px;
+}
+
+/*
+ * Styles for HTML generated by javadoc.
+ *
+ * These are style classes that are used by the standard doclet to generate HTML documentation.
+ */
+
+/*
+ * Styles for document title and copyright.
+ */
+.clear {
+    clear:both;
+    height:0px;
+    overflow:hidden;
+}
+.aboutLanguage {
+    float:right;
+    padding:0px 21px;
+    font-size:11px;
+    z-index:200;
+    margin-top:-9px;
+}
+.legalCopy {
+    margin-left:.5em;
+}
+.bar a, .bar a:link, .bar a:visited, .bar a:active {
+    color:#FFFFFF;
+    text-decoration:none;
+}
+.bar a:hover, .bar a:focus {
+    color:#bb7a2a;
+}
+.tab {
+    background-color:#0066FF;
+    color:#ffffff;
+    padding:8px;
+    width:5em;
+    font-weight:bold;
+}
+/*
+ * Styles for navigation bar.
+ */
+.bar {
+    background-color:#4D7A97;
+    color:#FFFFFF;
+    padding:.8em .5em .4em .8em;
+    height:auto;/*height:1.8em;*/
+    font-size:11px;
+    margin:0;
+}
+.navPadding {
+    padding-top: 107px;
+}
+.fixedNav {
+    position:fixed;
+    width:100%;
+    z-index:999;
+    background-color:#ffffff;
+}
+.topNav {
+    background-color:#4D7A97;
+    color:#FFFFFF;
+    float:left;
+    padding:0;
+    width:100%;
+    clear:right;
+    height:2.8em;
+    padding-top:10px;
+    overflow:hidden;
+    font-size:12px; 
+}
+.bottomNav {
+    margin-top:10px;
+    background-color:#4D7A97;
+    color:#FFFFFF;
+    float:left;
+    padding:0;
+    width:100%;
+    clear:right;
+    height:2.8em;
+    padding-top:10px;
+    overflow:hidden;
+    font-size:12px;
+}
+.subNav {
+    background-color:#dee3e9;
+    float:left;
+    width:100%;
+    overflow:hidden;
+    font-size:12px;
+}
+.subNav div {
+    clear:left;
+    float:left;
+    padding:0 0 5px 6px;
+    text-transform:uppercase;
+}
+ul.navList, ul.subNavList {
+    float:left;
+    margin:0 25px 0 0;
+    padding:0;
+}
+ul.navList li{
+    list-style:none;
+    float:left;
+    padding: 5px 6px;
+    text-transform:uppercase;
+}
+ul.navListSearch {
+    float:right;
+    margin:0 0 0 0;
+    padding:0;
+}
+ul.navListSearch li {
+    list-style:none;
+    float:right;
+    padding: 5px 6px;
+    text-transform:uppercase;
+}
+ul.navListSearch li label {
+    position:relative;
+    right:-16px;
+}
+ul.subNavList li {
+    list-style:none;
+    float:left;
+}
+.topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited {
+    color:#FFFFFF;
+    text-decoration:none;
+    text-transform:uppercase;
+}
+.topNav a:hover, .bottomNav a:hover {
+    text-decoration:none;
+    color:#bb7a2a;
+    text-transform:uppercase;
+}
+.navBarCell1Rev {
+    background-color:#F8981D;
+    color:#253441;
+    margin: auto 5px;
+}
+.skipNav {
+    position:absolute;
+    top:auto;
+    left:-9999px;
+    overflow:hidden;
+}
+/*
+ * Styles for page header and footer.
+ */
+.header, .footer {
+    clear:both;
+    margin:0 20px;
+    padding:5px 0 0 0;
+}
+.indexNav {
+    position:relative;
+    font-size:12px;
+    background-color:#dee3e9;
+}
+.indexNav ul {
+    margin-top:0;
+    padding:5px;
+}
+.indexNav ul li {
+    display:inline;
+    list-style-type:none;
+    padding-right:10px;
+    text-transform:uppercase;
+}
+.indexNav h1 {
+    font-size:13px;
+}
+.title {
+    color:#2c4557;
+    margin:10px 0;
+}
+.subTitle {
+    margin:5px 0 0 0;
+}
+.header ul {
+    margin:0 0 15px 0;
+    padding:0;
+}
+.footer ul {
+    margin:20px 0 5px 0;
+}
+.header ul li, .footer ul li {
+    list-style:none;
+    font-size:13px;
+}
+/*
+ * Styles for headings.
+ */
+div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 {
+    background-color:#dee3e9;
+    border:1px solid #d0d9e0;
+    margin:0 0 6px -8px;
+    padding:7px 5px;
+}
+ul.blockList ul.blockList ul.blockList li.blockList h3 {
+    background-color:#dee3e9;
+    border:1px solid #d0d9e0;
+    margin:0 0 6px -8px;
+    padding:7px 5px;
+}
+ul.blockList ul.blockList li.blockList h3 {
+    padding:0;
+    margin:15px 0;
+}
+ul.blockList li.blockList h2 {
+    padding:0px 0 20px 0;
+}
+/*
+ * Styles for page layout containers.
+ */
+.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer,
+.allClassesContainer, .allPackagesContainer {
+    clear:both;
+    padding:10px 20px;
+    position:relative;
+}
+.indexContainer {
+    margin:10px;
+    position:relative;
+    font-size:12px;
+}
+.indexContainer h2 {
+    font-size:13px;
+    padding:0 0 3px 0;
+}
+.indexContainer ul {
+    margin:0;
+    padding:0;
+}
+.indexContainer ul li {
+    list-style:none;
+    padding-top:2px;
+}
+.contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt {
+    font-size:12px;
+    font-weight:bold;
+    margin:10px 0 0 0;
+    color:#4E4E4E;
+}
+.contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd {
+    margin:5px 0 10px 0px;
+    font-size:14px;
+    font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif;
+}
+.serializedFormContainer dl.nameValue dt {
+    margin-left:1px;
+    font-size:1.1em;
+    display:inline;
+    font-weight:bold;
+}
+.serializedFormContainer dl.nameValue dd {
+    margin:0 0 0 1px;
+    font-size:1.1em;
+    display:inline;
+}
+/*
+ * Styles for lists.
+ */
+li.circle {
+    list-style:circle;
+}
+ul.horizontal li {
+    display:inline;
+    font-size:0.9em;
+}
+ul.inheritance {
+    margin:0;
+    padding:0;
+}
+ul.inheritance li {
+    display:inline;
+    list-style:none;
+}
+ul.inheritance li ul.inheritance {
+    margin-left:15px;
+    padding-left:15px;
+    padding-top:1px;
+}
+ul.blockList, ul.blockListLast {
+    margin:10px 0 10px 0;
+    padding:0;
+}
+ul.blockList li.blockList, ul.blockListLast li.blockList {
+    list-style:none;
+    margin-bottom:15px;
+    line-height:1.4;
+}
+ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList {
+    padding:0px 20px 5px 10px;
+    border:1px solid #ededed; 
+    background-color:#f8f8f8;
+}
+ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList {
+    padding:0 0 5px 8px;
+    background-color:#ffffff;
+    border:none;
+}
+ul.blockList ul.blockList ul.blockList ul.blockList li.blockList {
+    margin-left:0;
+    padding-left:0;
+    padding-bottom:15px;
+    border:none;
+}
+ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast {
+    list-style:none;
+    border-bottom:none;
+    padding-bottom:0;
+}
+table tr td dl, table tr td dl dt, table tr td dl dd {
+    margin-top:0;
+    margin-bottom:1px;
+}
+/*
+ * Styles for tables.
+ */
+.overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary,
+.requiresSummary, .packagesSummary, .providesSummary, .usesSummary {
+    width:100%;
+    border-spacing:0;
+    border-left:1px solid #EEE; 
+    border-right:1px solid #EEE; 
+    border-bottom:1px solid #EEE; 
+}
+.overviewSummary, .memberSummary, .requiresSummary, .packagesSummary, .providesSummary, .usesSummary  {
+    padding:0px;
+}
+.overviewSummary caption, .memberSummary caption, .typeSummary caption,
+.useSummary caption, .constantsSummary caption, .deprecatedSummary caption,
+.requiresSummary caption, .packagesSummary caption, .providesSummary caption, .usesSummary caption {
+    position:relative;
+    text-align:left;
+    background-repeat:no-repeat;
+    color:#253441;
+    font-weight:bold;
+    clear:none;
+    overflow:hidden;
+    padding:0px;
+    padding-top:10px;
+    padding-left:1px;
+    margin:0px;
+    white-space:pre;
+}
+.overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link,
+.constantsSummary caption a:link, .deprecatedSummary caption a:link,
+.requiresSummary caption a:link, .packagesSummary caption a:link, .providesSummary caption a:link,
+.usesSummary caption a:link,
+.overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover,
+.constantsSummary caption a:hover, .deprecatedSummary caption a:hover,
+.requiresSummary caption a:hover, .packagesSummary caption a:hover, .providesSummary caption a:hover,
+.usesSummary caption a:hover,
+.overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active,
+.constantsSummary caption a:active, .deprecatedSummary caption a:active,
+.requiresSummary caption a:active, .packagesSummary caption a:active, .providesSummary caption a:active,
+.usesSummary caption a:active,
+.overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited,
+.constantsSummary caption a:visited, .deprecatedSummary caption a:visited,
+.requiresSummary caption a:visited, .packagesSummary caption a:visited, .providesSummary caption a:visited,
+.usesSummary caption a:visited {
+    color:#FFFFFF;
+}
+.useSummary caption a:link, .useSummary caption a:hover, .useSummary caption a:active,
+.useSummary caption a:visited {
+    color:#1f389c;
+}
+.overviewSummary caption span, .memberSummary caption span, .typeSummary caption span,
+.useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span,
+.requiresSummary caption span, .packagesSummary caption span, .providesSummary caption span,
+.usesSummary caption span {
+    white-space:nowrap;
+    padding-top:5px;
+    padding-left:12px;
+    padding-right:12px;
+    padding-bottom:7px;
+    display:inline-block;
+    float:left;
+    background-color:#F8981D;
+    border: none;
+    height:16px;
+}
+.memberSummary caption span.activeTableTab span, .packagesSummary caption span.activeTableTab span,
+.overviewSummary caption span.activeTableTab span, .typeSummary caption span.activeTableTab span {
+    white-space:nowrap;
+    padding-top:5px;
+    padding-left:12px;
+    padding-right:12px;
+    margin-right:3px;
+    display:inline-block;
+    float:left;
+    background-color:#F8981D;
+    height:16px;
+}
+.memberSummary caption span.tableTab span, .packagesSummary caption span.tableTab span,
+.overviewSummary caption span.tableTab span, .typeSummary caption span.tableTab span {
+    white-space:nowrap;
+    padding-top:5px;
+    padding-left:12px;
+    padding-right:12px;
+    margin-right:3px;
+    display:inline-block;
+    float:left;
+    background-color:#4D7A97;
+    height:16px;
+}
+.memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab,
+.packagesSummary caption span.tableTab, .packagesSummary caption span.activeTableTab,
+.overviewSummary caption span.tableTab, .overviewSummary caption span.activeTableTab,
+.typeSummary caption span.tableTab, .typeSummary caption span.activeTableTab {
+    padding-top:0px;
+    padding-left:0px;
+    padding-right:0px;
+    background-image:none;
+    float:none;
+    display:inline;
+}
+.overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd,
+.useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd,
+.requiresSummary .tabEnd, .packagesSummary .tabEnd, .providesSummary .tabEnd, .usesSummary .tabEnd {
+    display:none;
+    width:5px;
+    position:relative;
+    float:left;
+    background-color:#F8981D;
+}
+.memberSummary .activeTableTab .tabEnd, .packagesSummary .activeTableTab .tabEnd,
+.overviewSummary .activeTableTab .tabEnd, .typeSummary .activeTableTab .tabEnd {
+    display:none;
+    width:5px;
+    margin-right:3px;
+    position:relative; 
+    float:left;
+    background-color:#F8981D;
+}
+.memberSummary .tableTab .tabEnd, .packagesSummary .tableTab .tabEnd,
+.overviewSummary .tableTab .tabEnd, .typeSummary .tableTab .tabEnd {
+    display:none;
+    width:5px;
+    margin-right:3px;
+    position:relative;
+    background-color:#4D7A97;
+    float:left;
+}
+.rowColor th, .altColor th {
+    font-weight:normal;
+}
+.overviewSummary td, .memberSummary td, .typeSummary td,
+.useSummary td, .constantsSummary td, .deprecatedSummary td,
+.requiresSummary td, .packagesSummary td, .providesSummary td, .usesSummary td {
+    text-align:left;
+    padding:0px 0px 12px 10px;
+}
+th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .useSummary th,
+.constantsSummary th, .packagesSummary th, td.colFirst, td.colSecond, td.colLast, .useSummary td,
+.constantsSummary td {
+    vertical-align:top;
+    padding-right:0px;
+    padding-top:8px;
+    padding-bottom:3px;
+}
+th.colFirst, th.colSecond, th.colLast, th.colConstructorName, th.colDeprecatedItemName, .constantsSummary th,
+.packagesSummary th {
+    background:#dee3e9;
+    text-align:left;
+    padding:8px 3px 3px 7px;
+}
+td.colFirst, th.colFirst {
+    font-size:13px;
+}
+td.colSecond, th.colSecond, td.colLast, th.colConstructorName, th.colDeprecatedItemName, th.colLast {
+    font-size:13px;
+}
+.constantsSummary th, .packagesSummary th {
+    font-size:13px;
+}
+.providesSummary th.colFirst, .providesSummary th.colLast, .providesSummary td.colFirst,
+.providesSummary td.colLast {
+    white-space:normal;
+    font-size:13px;
+}
+.overviewSummary td.colFirst, .overviewSummary th.colFirst,
+.requiresSummary td.colFirst, .requiresSummary th.colFirst,
+.packagesSummary td.colFirst, .packagesSummary td.colSecond, .packagesSummary th.colFirst, .packagesSummary th,
+.usesSummary td.colFirst, .usesSummary th.colFirst,
+.providesSummary td.colFirst, .providesSummary th.colFirst,
+.memberSummary td.colFirst, .memberSummary th.colFirst,
+.memberSummary td.colSecond, .memberSummary th.colSecond, .memberSummary th.colConstructorName,
+.typeSummary td.colFirst, .typeSummary th.colFirst {
+    vertical-align:top;
+}
+.packagesSummary th.colLast, .packagesSummary td.colLast {
+    white-space:normal;
+}
+td.colFirst a:link, td.colFirst a:visited,
+td.colSecond a:link, td.colSecond a:visited,
+th.colFirst a:link, th.colFirst a:visited,
+th.colSecond a:link, th.colSecond a:visited,
+th.colConstructorName a:link, th.colConstructorName a:visited,
+th.colDeprecatedItemName a:link, th.colDeprecatedItemName a:visited, 
+.constantValuesContainer td a:link, .constantValuesContainer td a:visited, 
+.allClassesContainer td a:link, .allClassesContainer td a:visited, 
+.allPackagesContainer td a:link, .allPackagesContainer td a:visited {
+    font-weight:bold;
+}
+.tableSubHeadingColor {
+    background-color:#EEEEFF;
+}
+.altColor, .altColor th {
+    background-color:#FFFFFF;
+}
+.rowColor, .rowColor th {
+    background-color:#EEEEEF;
+}
+/*
+ * Styles for contents.
+ */
+.description pre {
+    margin-top:0;
+}
+.deprecatedContent {
+    margin:0;
+    padding:10px 0;
+}
+.docSummary {
+    padding:0;
+}
+ul.blockList ul.blockList ul.blockList li.blockList h3 {
+    font-style:normal;
+}
+div.block {
+    font-size:14px;
+    font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif;
+}
+td.colLast div {
+    padding-top:0px;
+}
+td.colLast a {
+    padding-bottom:3px;
+}
+/*
+ * Styles for formatting effect.
+ */
+.sourceLineNo {
+    color:green;
+    padding:0 30px 0 0;
+}
+h1.hidden {
+    visibility:hidden;
+    overflow:hidden;
+    font-size:10px;
+}
+.block {
+    display:block;
+    margin:3px 10px 2px 0px;
+    color:#474747;
+}
+.deprecatedLabel, .descfrmTypeLabel, .implementationLabel, .memberNameLabel, .memberNameLink,
+.moduleLabelInPackage, .moduleLabelInType, .overrideSpecifyLabel, .packageLabelInType,
+.packageHierarchyLabel, .paramLabel, .returnLabel, .seeLabel, .simpleTagLabel,
+.throwsLabel, .typeNameLabel, .typeNameLink, .searchTagLink {
+    font-weight:bold;
+}
+.deprecationComment, .emphasizedPhrase, .interfaceName {
+    font-style:italic;
+}
+.deprecationBlock {
+    font-size:14px;
+    font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif;
+    border-style:solid;
+    border-width:thin;
+    border-radius:10px;
+    padding:10px;
+    margin-bottom:10px;
+    margin-right:10px;
+    display:inline-block;
+}
+div.block div.deprecationComment, div.block div.block span.emphasizedPhrase,
+div.block div.block span.interfaceName {
+    font-style:normal;
+}
+div.contentContainer ul.blockList li.blockList h2 {
+    padding-bottom:0px;
+}
+/*
+ * Styles for IFRAME.
+ */
+.mainContainer {
+    margin:0 auto; 
+    padding:0; 
+    height:100%; 
+    width:100%; 
+    position:fixed; 
+    top:0; 
+    left:0;
+}
+.leftContainer {
+    height:100%;
+    position:fixed;
+    width:320px;
+}
+.leftTop {
+    position:relative;
+    float:left;
+    width:315px;
+    top:0;
+    left:0;
+    height:30%;
+    border-right:6px solid #ccc;
+    border-bottom:6px solid #ccc;
+}
+.leftBottom {
+    position:relative;
+    float:left;
+    width:315px;
+    bottom:0;
+    left:0;
+    height:70%;
+    border-right:6px solid #ccc;
+    border-top:1px solid #000;
+}
+.rightContainer {
+    position:absolute;
+    left:320px;
+    top:0;
+    bottom:0;
+    height:100%;
+    right:0;
+    border-left:1px solid #000;
+}
+.rightIframe {
+    margin:0;
+    padding:0;
+    height:100%;
+    right:30px;
+    width:100%;
+    overflow:visible;
+    margin-bottom:30px;
+}
+/*
+ * Styles specific to HTML5 elements.
+ */
+main, nav, header, footer, section {
+    display:block;
+}
+/*
+ * Styles for javadoc search.
+ */
+.ui-autocomplete-category {
+    font-weight:bold;
+    font-size:15px;
+    padding:7px 0 7px 3px;
+    background-color:#4D7A97;
+    color:#FFFFFF;
+}
+.resultItem {
+    font-size:13px;
+}
+.ui-autocomplete {
+    max-height:85%;
+    max-width:65%;
+    overflow-y:scroll;
+    overflow-x:scroll;
+    white-space:nowrap;
+    box-shadow: 0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23);
+}
+ul.ui-autocomplete {
+    position:fixed;
+    z-index:999999;
+}
+ul.ui-autocomplete  li {
+    float:left;
+    clear:both;
+    width:100%;
+}
+.resultHighlight {
+    font-weight:bold;
+}
+#search {
+    background-image:url('resources/glass.png');
+    background-size:13px;
+    background-repeat:no-repeat;
+    background-position:2px 3px;
+    padding-left:20px;
+    position:relative;
+    right:-18px;
+}
+#reset {
+    background-color: rgb(255,255,255);
+    background-image:url('resources/x.png');
+    background-position:center;
+    background-repeat:no-repeat;
+    background-size:12px;
+    border:0 none;
+    width:16px;
+    height:17px;
+    position:relative;
+    left:-4px;
+    top:-4px;
+    font-size:0px;
+}
+.watermark {
+    color:#545454;
+}
+.searchTagDescResult {
+    font-style:italic;
+    font-size:11px;
+}
+.searchTagHolderResult {
+    font-style:italic;
+    font-size:12px;
+}
+.searchTagResult:before, .searchTagResult:target {
+    color:red;
+}
+.moduleGraph span {
+    display:none;
+    position:absolute;
+}
+.moduleGraph:hover span {
+    display:block;
+    margin: -100px 0 0 100px;
+    z-index: 1;
+}
+.methodSignature {
+    white-space:normal;
+}
+
+/*
+ * Styles for user-provided tables.
+ *
+ * borderless:
+ *      No borders, vertical margins, styled caption.
+ *      This style is provided for use with existing doc comments.
+ *      In general, borderless tables should not be used for layout purposes.
+ *
+ * plain:
+ *      Plain borders around table and cells, vertical margins, styled caption.
+ *      Best for small tables or for complex tables for tables with cells that span
+ *      rows and columns, when the "striped" style does not work well.
+ *
+ * striped:
+ *      Borders around the table and vertical borders between cells, striped rows,
+ *      vertical margins, styled caption.
+ *      Best for tables that have a header row, and a body containing a series of simple rows.
+ */
+
+table.borderless,
+table.plain,
+table.striped {
+    margin-top: 10px;
+    margin-bottom: 10px;
+}
+table.borderless > caption,
+table.plain > caption,
+table.striped > caption {
+    font-weight: bold;
+    font-size: smaller;
+}
+table.borderless th, table.borderless td,
+table.plain th, table.plain td,
+table.striped th, table.striped td {
+    padding: 2px 5px;
+}
+table.borderless,
+table.borderless > thead > tr > th, table.borderless > tbody > tr > th, table.borderless > tr > th,
+table.borderless > thead > tr > td, table.borderless > tbody > tr > td, table.borderless > tr > td {
+    border: none;
+}
+table.borderless > thead > tr, table.borderless > tbody > tr, table.borderless > tr {
+    background-color: transparent;
+}
+table.plain {
+    border-collapse: collapse;
+    border: 1px solid black;
+}
+table.plain > thead > tr, table.plain > tbody tr, table.plain > tr {
+    background-color: transparent;
+}
+table.plain > thead > tr > th, table.plain > tbody > tr > th, table.plain > tr > th,
+table.plain > thead > tr > td, table.plain > tbody > tr > td, table.plain > tr > td {
+    border: 1px solid black;
+}
+table.striped {
+    border-collapse: collapse;
+    border: 1px solid black;
+}
+table.striped > thead {
+    background-color: #E3E3E3;
+}
+table.striped > thead > tr > th, table.striped > thead > tr > td {
+    border: 1px solid black;
+}
+table.striped > tbody > tr:nth-child(even) {
+    background-color: #EEE
+}
+table.striped > tbody > tr:nth-child(odd) {
+    background-color: #FFF
+}
+table.striped > tbody > tr > th, table.striped > tbody > tr > td {
+    border-left: 1px solid black;
+    border-right: 1px solid black;
+}
+table.striped > tbody > tr > th {
+    font-weight: normal;
+}

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/images/Bildnachweise.html

@@ -0,0 +1,112 @@
+<html>
+<head>
+<title>Bildnachweise</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<head>
+<body>
+<h2>Akku</h2>
+<img src="Akku.png" style="float:left">
+Bild von <a href="https://pixabay.com/de/users/Clker-Free-Vector-Images-3736/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=312747">Clker-Free-Vector-Images</a> auf <a href="https://pixabay.com/de/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=312747">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/de/vectors/batterie-elektrische-strom-positiv-312747/">https://pixabay.com/de/vectors/batterie-elektrische-strom-positiv-312747/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Fass+Atommuell</h2>
+<img src="Fass.png" style="float:left"> <img src="Atommuell.png" style="float:left">
+Bild von <a href="https://pixabay.com/users/OpenClipart-Vectors-30363/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=146440">OpenClipart-Vectors</a> auf <a href="https://pixabay.com/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=146440">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/vectors/oil-barrel-black-mineral-oil-146440/">https://pixabay.com/vectors/oil-barrel-black-mineral-oil-146440/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+</body>
+<h2>Feuer</h2>
+<img src="Feuer.png" style="float:left"> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<h2>Platten mit und ohne Knöpfe/Schalter usw</h2>
+<img src="Wand.png"><img src="Rufknopf.png"><img src="RufknopfAus.png"><img src="SchalterEin.png"><img src="SchalterAus.png"><img src="Schloss.png"><img src="Stromquelle1.png"><img src="Stromquelle2.png"><img src="Stromquelle3.png"><img src="Stromquelle4.png">
+<br>Bild auf Grundlage von <a href="https://pixabay.com/users/stux-12364/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=186943">Thanks for your Like • donations welcome</a> auf <a href="https://pixabay.com/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=186943">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/photos/mdf-platte-structure-fund-wood-186943/">https://pixabay.com/photos/mdf-platte-structure-fund-wood-186943/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Strom</h2>
+<img src="Strom.png" style="float:left"> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<br><br>
+<h2>Steine</h2>
+<img src="Steine.png" style="float:left">
+Bild von <a href="https://pixabay.com/de/users/Clker-Free-Vector-Images-3736/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=48279">Clker-Free-Vector-Images</a> auf <a href="https://pixabay.com/de/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=48279">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/de/vectors/felsen-felsbrocken-stein-48279/">https://pixabay.com/de/vectors/felsen-felsbrocken-stein-48279/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Roboter</h2>
+<img src="Roboter.png"><img src="Robby.png"><img src="Robita.png"><img src="Robocount.png"><img src="Robson.png">
+<br>Bild auf <a href="https://publicdomainvectors.org">Public Domain Vectors</a>
+<br>URL: <a href="https://publicdomainvectors.org/de/kostenlose-vektorgrafiken/Comic-Roboter/47643.html">https://publicdomainvectors.org/de/kostenlose-vektorgrafiken/Comic-Roboter/47643.html</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Public Domain
+<h2>Feuerlöscher</h2>
+<img src="Feuerloescher.png" style="float:left">
+Bild von <a href="https://pixabay.com/users/JJuni-27151/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=1139909">JJuni</a> auf  <a href="https://pixabay.com/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=1139909">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/illustrations/fire-extinguisher-fire-fire-truck-1139909/">https://pixabay.com/illustrations/fire-extinguisher-fire-fire-truck-1139909/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Bombe</h2>
+<img src="Bombe.png" style="float:left">
+Bild von<a href="https://pixabay.com/fr/users/Clker-Free-Vector-Images-3736/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=33424">Clker-Free-Vector-Images</a> auf <a href="https://pixabay.com/fr/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=33424">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/fr/vectors/bombe-engin-explosif-grenade-33424/">https://pixabay.com/fr/vectors/bombe-engin-explosif-grenade-33424/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Diamant</h2>
+<img src="Diamant.png" style="float:left">
+Bild von <a href="https://pixabay.com/de/users/Wild0ne-920941/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=1221161">M. Maggs</a> auf <a href="https://pixabay.com/de/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=1221161">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/de/vectors/gems-edelsteine-wertvolle-juwel-1221161/">https://pixabay.com/de/vectors/gems-edelsteine-wertvolle-juwel-1221161/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Einsatzleiter</h2>
+<img src="Person.png" style="float:left">
+Bild von <a href="https://pixabay.com/de/users/kasiagrafik-10628923/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=3812661">kasiagrafik</a> auf <a href="https://pixabay.com/de/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=3812661">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/de/illustrations/feuerwehrmann-feuer-löschen-3812661/">https://pixabay.com/de/illustrations/feuerwehrmann-feuer-löschen-3812661/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Schraube</h2>
+<img src="Schraube.png" style="float:left">
+Bild von <a href="https://pixabay.com/de/users/Clker-Free-Vector-Images-3736/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=33597">Clker-Free-Vector-Images</a> auf <a href="https://pixabay.com/de/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=33597">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/de/vectors/schrauben-metall-eisen-verschluss-33597/">https://pixabay.com/de/vectors/schrauben-metall-eisen-verschluss-33597/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Portal</h2>
+<img src="Portal.png" style="float:left">
+Grundlage des Bildes auf <a href="https://www.maxpixel.net">Max Pixel</a>
+<br>URL: <a href="https://www.maxpixel.net/Picture-Frame-Ring-Round-Circle-Shape-Pair-2885023">https://www.maxpixel.net/Picture-Frame-Ring-Round-Circle-Shape-Pair-2885023</a>
+<br>Lizenz: <a href="https://creativecommons.org/share-your-work/public-domain/cc0/">CC0 - Public Domain </a>
+<h2>Schlüssel</h2>
+<img src="Schluessel.png" style="float:left">
+Bild auf <a href="https://publicdomainvectors.org">Public Domain Vectors</a>
+<br>URL: <a href="https://publicdomainvectors.org/en/free-clipart/Vector-clip-art-of-grey-shaded-metal-door-key/21166.html">https://publicdomainvectors.org/en/free-clipart/Vector-clip-art-of-grey-shaded-metal-door-key/21166.html</a>
+<br>Lizenz: Public Domain
+<h2>Aufzug</h2>
+<img src="Aufzug.png" ><img src="Aufzugschacht.png" >
+<img src="Aufzugschacht2.png" >
+<br> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<h2>Bodenplatten</h2>
+<img src="bluerock.png" ><img src="bluerock1.png" ><img src="bluerock2.png" ><img src="bluerock3.png" ><img src="Bodenplatte.png" ><img src="Bodenplatte1.png" ><img src="Kontaktplatte.png" >
+<br> Selbst gezeichnet (Thomas Schaller, ZPG Informatik) mit Muster aus Gimp 2.0
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<h2>Ölfleck</h2>
+<img src="Oelfleck.png" style="float:left"> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<h2>Fragezeichen</h2>
+<img src="Gegenstand.png" style="float:left"> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<h2>Brennstab</h2>
+<img src="Brennstab.png" style="float:left"> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<h2>Türen</h2>
+<img src="Tuer2.png" style="float:left"> <img src="Tuer1.png" style="float:left">Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<br>
+<br>
+<h2>Sperrfläche</h2>
+<img src="warnung1.png" style="float:left"> Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<br><br>
+<h2>Steinwände</h2>
+<img src="Stein.png" style="float:left">
+Bild auf Grundlage von <a href="https://pixabay.com/de/users/skeeze-272447/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=1429207">skeeze</a> auf <a href="https://pixabay.com/de/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=1429207">Pixabay</a>
+<br>URL: <a href="https://pixabay.com/de/photos/kiesel-steine-felsen-landschaftsbau-1429207/">https://pixabay.com/de/photos/kiesel-steine-felsen-landschaftsbau-1429207/</a> (Abrufdatum: 09.10.2019)
+<br>Lizenz: Pixabay License, Freie kommerzielle Nutzung, Kein Bildnachweis nötig
+<h2>Pfeile</h2>
+<img src="pfeil0.png"><img src="pfeil90.png"><img src="pfeil180.png"><img src="pfeil270.png">
+Selbst gezeichnet (Thomas Schaller, ZPG Informatik)
+<br>Lizenz: <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/de/">CC CC BY-NC-SA 3.0 DE</a>
+<br><br>
+</html>

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/project.greenfoot

@@ -0,0 +1,299 @@
+#Greenfoot project file
+class.AB1.image=Robita.png
+class.AB10.image=Roboter.png
+class.AB3.image=Robby.png
+class.AB4.image=Robby.png
+class.AB5.image=Robita.png
+class.AB6_AB7.image=Robocount.png
+class.AB8.image=Robson.png
+class.AB9.image=Robson.png
+class.EinsatzLeiter.image=person.png
+class.Gegenstand.image=Gegenstand.png
+class.Roboter.image=Roboter.png
+class.RoboterWelt.image=Bodenplatte.png
+class.Schalter.image=SchalterAus.png
+class.Wand.image=Wand.png
+dependency1.from=RoboterWelt
+dependency1.to=ReadWrite
+dependency1.type=UsesDependency
+dependency10.from=RoboterWelt
+dependency10.to=AB5
+dependency10.type=UsesDependency
+dependency11.from=RoboterWelt
+dependency11.to=AB6_AB7
+dependency11.type=UsesDependency
+dependency12.from=RoboterWelt
+dependency12.to=AB8
+dependency12.type=UsesDependency
+dependency13.from=RoboterWelt
+dependency13.to=Aufzugknopf
+dependency13.type=UsesDependency
+dependency14.from=RoboterWelt
+dependency14.to=AB9
+dependency14.type=UsesDependency
+dependency15.from=RoboterWelt
+dependency15.to=EinsatzLeiter
+dependency15.type=UsesDependency
+dependency16.from=RoboterWelt
+dependency16.to=AB10
+dependency16.type=UsesDependency
+dependency17.from=RoboterWelt
+dependency17.to=Message
+dependency17.type=UsesDependency
+dependency18.from=EinsatzLeiter
+dependency18.to=AB9
+dependency18.type=UsesDependency
+dependency19.from=EinsatzLeiter
+dependency19.to=AB10
+dependency19.type=UsesDependency
+dependency2.from=RoboterWelt
+dependency2.to=Wand
+dependency2.type=UsesDependency
+dependency20.from=EinsatzLeiter
+dependency20.to=RoboterWelt
+dependency20.type=UsesDependency
+dependency21.from=Gegenstand
+dependency21.to=Schalter
+dependency21.type=UsesDependency
+dependency22.from=Gegenstand
+dependency22.to=Wand
+dependency22.type=UsesDependency
+dependency23.from=Wand
+dependency23.to=Schalter
+dependency23.type=UsesDependency
+dependency24.from=Wand
+dependency24.to=Roboter
+dependency24.type=UsesDependency
+dependency25.from=Roboter
+dependency25.to=Gegenstand
+dependency25.type=UsesDependency
+dependency26.from=Roboter
+dependency26.to=RoboterWelt
+dependency26.type=UsesDependency
+dependency27.from=Roboter
+dependency27.to=Schalter
+dependency27.type=UsesDependency
+dependency28.from=Roboter
+dependency28.to=AB1
+dependency28.type=UsesDependency
+dependency29.from=Roboter
+dependency29.to=ReadWrite
+dependency29.type=UsesDependency
+dependency3.from=RoboterWelt
+dependency3.to=Gegenstand
+dependency3.type=UsesDependency
+dependency30.from=Roboter
+dependency30.to=Wand
+dependency30.type=UsesDependency
+dependency31.from=Roboter
+dependency31.to=Message
+dependency31.type=UsesDependency
+dependency32.from=Schalter
+dependency32.to=RoboterWelt
+dependency32.type=UsesDependency
+dependency33.from=Schalter
+dependency33.to=Roboter
+dependency33.type=UsesDependency
+dependency34.from=Schalter
+dependency34.to=Wand
+dependency34.type=UsesDependency
+dependency35.from=Schalter
+dependency35.to=Gegenstand
+dependency35.type=UsesDependency
+dependency36.from=Aufzugknopf
+dependency36.to=Gegenstand
+dependency36.type=UsesDependency
+dependency4.from=RoboterWelt
+dependency4.to=Roboter
+dependency4.type=UsesDependency
+dependency5.from=RoboterWelt
+dependency5.to=AB1
+dependency5.type=UsesDependency
+dependency6.from=RoboterWelt
+dependency6.to=Schalter
+dependency6.type=UsesDependency
+dependency7.from=RoboterWelt
+dependency7.to=AB2
+dependency7.type=UsesDependency
+dependency8.from=RoboterWelt
+dependency8.to=AB3
+dependency8.type=UsesDependency
+dependency9.from=RoboterWelt
+dependency9.to=AB4
+dependency9.type=UsesDependency
+editor.fx.0.height=739
+editor.fx.0.width=816
+editor.fx.0.x=128
+editor.fx.0.y=143
+height=905
+package.numDependencies=36
+package.numTargets=19
+project.charset=windows-1252
+publish.hasSource=true
+publish.locked=false
+publish.longDesc=
+publish.shortDesc=
+publish.tags=demo\ school\ with-source
+publish.title=GFRobot_Szenario
+publish.url=
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+simulation.speed=78
+target1.height=50
+target1.name=EinsatzLeiter
+target1.naviview.expanded=true
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=100
+target1.x=100
+target1.y=190
+target10.height=50
+target10.name=AB3
+target10.naviview.expanded=false
+target10.showInterface=false
+target10.type=ClassTarget
+target10.width=80
+target10.x=190
+target10.y=310
+target11.height=50
+target11.name=Schalter
+target11.naviview.expanded=true
+target11.showInterface=false
+target11.type=ClassTarget
+target11.width=80
+target11.x=190
+target11.y=490
+target12.height=50
+target12.name=AB4
+target12.naviview.expanded=false
+target12.showInterface=false
+target12.type=ClassTarget
+target12.width=80
+target12.x=10
+target12.y=370
+target13.height=50
+target13.name=AB5
+target13.naviview.expanded=false
+target13.showInterface=false
+target13.type=ClassTarget
+target13.width=80
+target13.x=100
+target13.y=370
+target14.height=50
+target14.name=AB6
+target14.showInterface=false
+target14.type=ClassTarget
+target14.width=80
+target14.x=0
+target14.y=0
+target15.height=50
+target15.name=Roboter
+target15.naviview.expanded=true
+target15.showInterface=false
+target15.type=ClassTarget
+target15.width=80
+target15.x=160
+target15.y=70
+target16.height=50
+target16.name=AB6_AB7
+target16.naviview.expanded=true
+target16.showInterface=false
+target16.type=ClassTarget
+target16.width=80
+target16.x=190
+target16.y=130
+target17.height=50
+target17.name=AB8
+target17.naviview.expanded=false
+target17.showInterface=false
+target17.type=ClassTarget
+target17.width=80
+target17.x=160
+target17.y=10
+target18.height=50
+target18.name=AB9
+target18.naviview.expanded=false
+target18.showInterface=false
+target18.type=ClassTarget
+target18.width=80
+target18.x=120
+target18.y=250
+target19.height=50
+target19.name=AB10
+target19.naviview.expanded=false
+target19.showInterface=false
+target19.type=ClassTarget
+target19.width=80
+target19.x=10
+target19.y=310
+target2.height=50
+target2.name=Aufzugknopf
+target2.naviview.expanded=true
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=100
+target2.x=10
+target2.y=80
+target3.height=50
+target3.name=Message
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=80
+target3.x=0
+target3.y=0
+target4.height=50
+target4.name=RoboterWelt
+target4.naviview.expanded=true
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=100
+target4.x=10
+target4.y=250
+target5.height=50
+target5.name=Gegenstand
+target5.naviview.expanded=true
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=90
+target5.x=100
+target5.y=550
+target6.height=50
+target6.name=Wand
+target6.naviview.expanded=true
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=80
+target6.x=70
+target6.y=10
+target7.height=50
+target7.name=ReadWrite
+target7.naviview.expanded=false
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=80
+target7.x=10
+target7.y=490
+target8.height=50
+target8.name=AB1
+target8.naviview.expanded=true
+target8.showInterface=false
+target8.type=ClassTarget
+target8.width=80
+target8.x=10
+target8.y=150
+target9.height=50
+target9.name=AB2
+target9.naviview.expanded=false
+target9.showInterface=false
+target9.type=ClassTarget
+target9.width=80
+target9.x=100
+target9.y=310
+version=3.0.0
+width=1124
+world.lastInstantiated=RoboterWelt
+xPosition=472
+yPosition=71

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/secret

@@ -0,0 +1,17 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238
+1368404363
+1627578562
+2098724778
+1157
+2336
+168090008
+2336
+1425899477
+4039
+2729

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/userhome/greenfoot/greenfoot-debuglog.txt

@@ -0,0 +1,11 @@
+Greenfoot run started: Wed Sep 28 07:49:11 CEST 2016
+Greenfoot version: 2.4.1
+Java version 1.8.0_05
+Virtual machine: Java HotSpot(TM) 64-Bit Server VM 25.5-b02 (Oracle Corporation)
+Running on: Windows 8.1 6.3 (amd64)
+Java Home: C:\Program Files\Java\jdk1.8.0_05\jre
+----
+Opening project: F:\Informatik\Fortbildung Jahreskurs\Owncloud\JahresKurs Informatik\Head\01_Einfuehrung_in_die_Programmierung\01_ReaktorRobot\4_Loesungen\01_ReaktorRobot_Szenario_Loesung
+1475041753390: Listening for JDWP connection on address: javadebug
+Connected to debug VM via dt_shmem transport...
+Communication with debug VM fully established.

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/userhome/greenfoot/greenfoot.properties

@@ -0,0 +1,26 @@
+#Greenfoot properties. Settings in this file override "bluej.defs" and "greenfoot.defs"
+#Wed Sep 28 08:01:49 CEST 2016
+bluej.language=english
+bluej.editor.fontsize=12
+bluej.editor.displayLineNumbers=true
+bluej.accessibility.support=false
+greenfoot.uid=efba18f3-5026-46ce-b480-5f66a7263445
+extensions.org.bluej.extensions.submitter.Submitter.settings.saslrealm=
+bluej.startWithTextEval=false
+bluej.terminal.y=16
+bluej.terminal.x=16
+bluej.openPackage1=F\:\\Informatik\\Fortbildung Jahreskurs\\Owncloud\\JahresKurs Informatik\\Head\\01_Einfuehrung_in_die_Programmierung\\01_ReaktorRobot\\4_Loesungen\\01_ReaktorRobot_Szenario_Loesung
+bluej.editor.scopeHilightingStrength=20
+bluej.debugger.y=194
+bluej.recentProject5=F\:\\Informatik\\Fortbildung Jahreskurs\\Greenfoot\\01_GreenfootRobot_Programmier_Lehrgang\\01_GreenfootRobot_Programmier_Lehrgang\\02_GFRobot_Szenario_20151006
+bluej.debugger.x=956
+bluej.recentProject4=F\:\\Informatik\\Fortbildung Jahreskurs\\Greenfoot\\01_GreenfootRobot_Programmier_Lehrgang\\01_GreenfootRobot_Programmier_Lehrgang\\02_GFRobot_Szenario_Kernkraft
+bluej.recentProject3=F\:\\Informatik\\Fortbildung Jahreskurs\\Greenfoot\\02_GFRobot_Szenario_Kernkraft
+bluej.recentProject2=F\:\\Informatik\\Fortbildung Jahreskurs\\Owncloud\\JahresKurs Informatik\\MaterialSammlung\\Tom_Dirk_ReaktorRobot\\4_Loesungen\\01_ReaktorRobot_Szenario_Loesung
+extensions.rmiextension.RMIExtension.settings.bluej.editor.fontsize=12
+bluej.recentProject1=F\:\\Informatik\\Fortbildung Jahreskurs\\Greenfoot\\01_ReaktorRobot_korrigiert\\4_Loesungen\\01_ReaktorRobot_Szenario_Loesung
+bluej.recentProject0=F\:\\Informatik\\Fortbildung Jahreskurs\\Owncloud\\JahresKurs Informatik\\Head\\01_Einfuehrung_in_die_Programmierung\\01_ReaktorRobot\\4_Loesungen\\01_ReaktorRobot_Szenario_Loesung
+bluej.preferences.y=16
+bluej.preferences.x=16
+greenfoot.url.javaStdLib=http\://download.oracle.com/javase/6/docs/api/
+extensions.rmiextension.RMIExtension.settings.greenfoot.player.name=Player

4_loesungen/01_ReaktorRobot_GF361_Szenario_Loesung/userhome/greenfoot/moe.properties

@@ -0,0 +1,2 @@
+#Moe Editor properties. Settings in this file override "moe.defs"
+#Wed Sep 28 08:01:49 CEST 2016

4_loesungen/02_Secret_Dateien_fuer_Lehrer/Hinweis zur Nutzung der Secret-Dateien.txt

@@ -0,0 +1,15 @@
+Hinweis zur Nutzung der Secret-Dateien:
+
+Im ReaktorRobot-Szenario lernen Schülerinnen und Schüler (im Folgenden Schüler genannt) programmieren, indem unterschiedliche Level mit differenziertem Schwierigkeitsgrad durchlaufen werden.
+Ein neues Level wird erreicht, wenn der Leveltest (AB1) bzw. die Einsätze (ab AB2) erfolgreich bestanden wurden. Für diesen Fall wird in der Datei "secret" im "ReaktorRobot_Szenario_Roh"-Ordner ein Eintrag gemacht, der dafür sorgt, dass ein neues Level beginnt.
+
+Man kann daher höhere Level nur erreichen, wenn man erfolgreich einen Einsatz erledigt. Zu jeder Zeit kann der Schüler oder Lehrer mit Rechtsklick auf die Welt (blauer Hintergrund) die Methode "geheZuLevel(int i)" aufrufen und so zu einem niedrigeren Level gehen bzw. zum aktuellen Level zurückkehren. Dies kann zu Diagnosezwecken ("Zeig doch mal, wie du im letzten Level die Aufgabe xy gelöst hast!") hilfreich sein.
+
+Mit Hilfe der Secret-Dateien kann ein Lehrer jedoch auch zu einem, bisher noch nicht erreichten, höheren Level wechseln. Dies kann beispielsweise nötig werden, falls das Szenario (und damit der erreichte Lernstand in Form des erreichten Levels) nicht gespeichert wurde oder das Szenario beim Synchronisieren des Schulrechners gelöscht wurde.
+
+Daher hier eine kurze Anleitung, wie der aktuelle Stand wieder hergestellt werden kann. Nehmen wir an, ein Schüler war vor einem Systemcrash bei AB7 und möchte in das entsprechende 7. Level zurück:
+1) Kopieren Sie die benötigte "secret_07"-Datei aus diesem Ordner in den "ReaktorRobot_Szenario_Roh"-Ordner im "3_Vorlagen_Tauschordner"-Verzeichnis
+2) Löschen Sie im "ReaktorRobot_Szenario_Roh"-Ordner die Datei "secret"
+3) Benennen Sie die "secret_07"-Datei in "secret" um
+
+Jetzt können Sie in Greenfoot das ReaktorRobot-Szenario starten - das 7.Level sollte nun erscheinen

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_02

@@ -0,0 +1,3 @@
+998536474
+1641901578
+1571042368

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_03

@@ -0,0 +1,4 @@
+998536474
+1641901578
+1571042368
+786474591

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_04

@@ -0,0 +1,5 @@
+998536474
+1641901578
+1571042368
+786474591
+2205

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_05

@@ -0,0 +1,6 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_06

@@ -0,0 +1,7 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_07

@@ -0,0 +1,8 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238
+1368404363

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_08

@@ -0,0 +1,9 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238
+1368404363
+1627578562

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_09

@@ -0,0 +1,10 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238
+1368404363
+1627578562
+2098724778

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_10

@@ -0,0 +1,11 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238
+1368404363
+1627578562
+2098724778
+1157

4_loesungen/02_Secret_Dateien_fuer_Lehrer/secret_alle

@@ -0,0 +1,15 @@
+998536474
+1641901578
+1571042368
+786474591
+2205
+3384
+946928238
+1368404363
+1627578562
+2098724778
+1157
+2336
+168090008
+2336
+1425899477