Web 0.14.35: Lektionen für das Selbststudium verständlicher

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is loosely inspired by Keep a Changelog.
 
 ### Changed
 
+- **Web 0.14.35, lessons easier for self-study:** VisuBot lesson 3 gets a new step „So sieht Java aus“ before the first Java exercise: where the Code area is, the square with a variable in Java, semicolons, the `for` head, curly brackets, upper and lower case, and how to solve a Java exercise (Im Editor öffnen, type, Prüfen); plus a Kompetenz and checklist item. VisuBot lesson 2 explains the counter `i` of the for loop (what `int i = 0`, `i < 5`, `i++` mean, table of the five runs). VisuBot says `true`/`false` like the editor instead of Ja/Nein (lesson text, hints, tasks). VisuBot lesson 1 (Struktogramm und Editor) says that every exercise ends with Prüfen, often in several worlds, and that the hints help. VisuStruct lesson 4 explains `"Text: " + variable` in the lesson text before the exercise „Rechteck“ (before, only its second hint did). Lesson 2 names the tool buttons Kopieren, Einfügen and Rückgängig for tablets without a keyboard and points to the Simulation button. The tasks of lessons 29–40 get a list „Du bist fertig, wenn …“ with things you can see in the window, so students working alone know when they are done (de/en/pt; VisuBot de/en).
 - **Web 0.14.34, broken lesson steps repaired:** lesson 3 step „Ausprobieren“ ended with „probiere Folgendes aus:“ and no list, and the checklist sat in the same step without its own heading; now there are four things to try (title, save in the workspace, open again in a second tab, export PNG and PDF), the step comes before the game, and „Checkliste“ is its own step (de/en/pt). VisuBot lesson „Sensoren“ step „Was liefert der Sensor?“ had no text; it now explains that a sensor gives a value, that a comparison turns it into `true` or `false` (table with three conditions), the comparison operators and `==` vs. `=` (de/en). The cloze explanation in lesson 4 pointed to a lesson „Java“; it is called „Struktogramm und Code“ (de/en/pt). New tests: the checklist stands in its own step „Checkliste“, and no text ends with a colon with nothing after it.
 - **Web 0.14.33, a game in every lesson:** every lesson now has at least one game before its checklist (Holger: Kompetenzen, game, checklist, quiz in every lesson). New: VisuStruct lesson 36 „Zahlenraten“ gets „Zu klein oder zu groß?“ (hints, smart guessing by halving, `Math.random` ranges, guess counter, `setEnabled`, 1 to 1000; de/en/pt). All 26 robot lessons without a game get one (de/en), using the existing game types: question rounds („Welcher Baustein?“, „Wie oft fährt er?“, „Welcher Datentyp?“, „Spiel den Computer“, „Befehl oder Sensor?“, „Kopf oder Fuß?“, „Linie oder nicht?“, „Wahr oder falsch?“, „Welcher Fall läuft?“, „Notbremse“, „Licht an oder aus?“, „Laut oder leise?“, „Zu schief?“, „Welche Farbe?“, „Welche LED leuchtet?“, „Welches Fach?“, „Was steht auf dem Bildschirm?“, „Wohin fährt er?“, „Stoppuhr und Akku“, „Welche Methode?“), „Bombe entschärfen“ with mBot2 code (L6 distance, L8 colours, L19 strings) and „Von tief nach hoch“ (order, L16 speaker). Robot lessons now end like the VisuStruct lessons with the steps game, „Checkliste“ and „Wissenstest“ (the last quiz moves from the last content step to its own step after the checklist; L2 and L22 keep their quizzes in place). Because steps were inserted, saved self-assessments and quiz answers in these lessons start fresh. Tests check that every lesson in both worlds has a game before the checklist. Ten robot lessons get a second „Bombe entschärfen“ round with mBot2 code (L3, L8, L10, L11, L15, L19, L20, L22, L23, L27). New game type `::: spiel fahrt` „Wo landet der mBot2?“ (`web/src/learn/driveGame.ts`, `web/src/ui/driveGameView.ts`): each round shows mBot2 code and a small map with walls, black and coloured fields; the pupil taps the field where the robot stops, then the robot drives the route on the map using the real simulation (L1, L3, L4, L7, L8, L10; a test drives every round and checks the target field). New game type `::: spiel kreuzwort` „Begriffe-Rätsel“: a standalone crossword with the terms of the lesson and a keyword (L5, L18, L24, L27, one per VisuBot part; de ROBOTER, SENSOR, AKTOR, METHODE, en ROBOT, SENSOR, SOUND, METHOD).
 - **Web 0.14.32, VisuBot: missing basics added:** four new robot lessons, inserted by file name without renaming (the series now has 27 lessons): „Struktogramm und Editor“ at the start (algorithm, Nassi-Shneiderman, the three building blocks with mBot2 examples, inserting/moving/deleting, saving and the workspace; exercise „Um die Ecke“), „Schritt für Schritt testen“ after Variables (simulation controls, desk-check table, logic error exercise „Die Spirale reparieren“ with a faulty start diagram), „Erst fahren, dann prüfen“ after the while loop (do-while vs. while table, structogram exercise, Java „Schritte zählen“) and „Notbremse mit break“ after buttons/joystick (endless loop with exit, Java `while (true)` + `break` with button A). Every robot lesson from lesson 4 on now has a Java exercise „Warum läuft das nicht?“ (`vb-fehler-<lesson>`): Ludwig's version of the lesson's program has one mistake (wrong case, typo, missing argument, unknown variable, missing quotation marks); the student runs it, reads the error message and fixes it. Lesson 22 gets the Java exercise „Rechteck mit Umdrehungen“. A test checks that every start diagram fails its exercise (de/en).

web/lessons/de/02-der-editor.md

@@ -59,15 +59,15 @@ Der Kasten aus dem Bereich Elemente heißt **Anweisung**. Oben wählst du, welch
 Für den Anfang brauchst du nur die Ausgabe. Texte, die genau so angezeigt werden sollen, schreibst du in **Anführungszeichen**.
 
 ::: diagramm l2-ausgabe.visustruct
-Zwei Ausgaben nacheinander. Öffne das Diagramm im Editor und starte die Simulation, um die Ausgabe zu sehen.
+Zwei Ausgaben nacheinander. Öffne das Diagramm im Editor und starte die [Simulation](#zeige-simulation) in den Werkzeugen, um die Ausgabe zu sehen. Genauer lernst du sie in Lektion 7 kennen.
 :::
 
 ## Verschieben, kopieren, löschen
 
 - **Verschieben:** Einen vorhandenen Kasten mit der Maus an eine neue Stelle ziehen.
-- **Kopieren und Einfügen:** Kasten auswählen, dann Strg+C und Strg+V (am Mac ⌘C und ⌘V). Die Kopie kommt hinter den ausgewählten Kasten.
+- **Kopieren und Einfügen:** Kasten auswählen, dann Strg+C und Strg+V (am Mac ⌘C und ⌘V). Die Kopie kommt hinter den ausgewählten Kasten. Ohne Tastatur, zum Beispiel auf dem Tablet, tippst du in den [Werkzeugen](#zeige-werkzeuge) auf **Kopieren** und **Einfügen**.
 - **Löschen:** Kasten auswählen und Entf drücken oder in den Werkzeugen auf den [Mülleimer](#zeige-loeschen) „Auswahl löschen“ klicken.
-- **Rückgängig:** Strg+Z macht den letzten Schritt rückgängig, Strg+Umschalt+Z stellt ihn wieder her (am Mac ⌘Z und ⌘⇧Z).
+- **Rückgängig:** Strg+Z macht den letzten Schritt rückgängig, Strg+Umschalt+Z stellt ihn wieder her (am Mac ⌘Z und ⌘⇧Z). Ohne Tastatur tippst du in den Werkzeugen auf [Rückgängig](#zeige-rueckgaengig).
 
 ## Übung: Hallo Welt
 

web/lessons/de/04-variablen-und-datentypen.md

@@ -84,7 +84,7 @@ Der Datentyp legt fest, welche Art von Wert in der Variablen stehen darf.
 Es gibt noch mehr Datentypen. Einen wirst du bald brauchen: `char` für ein **einzelnes Zeichen**, z. B. `char note = 'C'`. Ein `char` steht in **einfachen** Anführungszeichen. Genauer lernst du ihn in Lektion 17 kennen.
 
 ::: diagramm l05-datentypen.visustruct
-Drei Variablen mit verschiedenen Datentypen. Öffne das Diagramm und starte die Simulation.
+Drei Variablen mit verschiedenen Datentypen. Öffne das Diagramm und starte die [Simulation](#zeige-simulation).
 :::
 
 Wahrheitswerte begegnen dir vor allem in **Bedingungen**: `alter >= 18` ist entweder `true` oder `false`. Darum geht es in Lektion 8. Eine Variable vom Typ `boolean` bekommt einfach `true` oder `false`:
@@ -131,6 +131,17 @@ Ist der Rest 0, geht die Teilung auf. So prüfst du später, ob eine Zahl gerade
 
 Es gilt **Punkt vor Strich**, und Klammern werden zuerst ausgerechnet: `2 * (3 + 4)` ist 14.
 
+### Text und Ergebnis zusammen ausgeben
+
+Ein Ergebnis allein sagt wenig. Mit `+` hängst du einen Text und den Wert einer Variablen aneinander:
+
+```
+int alter = 14
+output: "Alter: " + alter
+```
+
+Das zeigt **Alter: 14**. Der Text in Anführungszeichen erscheint genau so, für `alter` setzt der Computer den Wert ein. Das Leerzeichen nach dem Doppelpunkt gehört zum Text, sonst steht dort `Alter:14`.
+
 ## Übung: Rechteck
 
 ::: übung l05-rechteck

web/lessons/de/29-knopf-im-fenster.md

@@ -169,6 +169,13 @@ Baue ein Fenster mit dem Titel „Knopf-Test“, 300 mal 200 Pixel groß, mit ei
 
 Zusatz: Lege einen zweiten Knopf „Ich auch“ daneben. In welcher Reihenfolge stehen die Knöpfe? Tausche die beiden `add`-Zeilen und probiere es noch einmal.
 
+**Du bist fertig, wenn …**
+
+- oben im Fenster „Knopf-Test“ steht,
+- das Fenster 300 Pixel breit und 200 Pixel hoch ist,
+- der Knopf „Klick mich“ nur so groß ist wie seine Schrift und nicht das ganze Fenster füllt,
+- sich der Knopf beim Klicken sichtbar eindrückt.
+
 ::: ludwig
 Jeder Knopf braucht eine eigene Variable, zum Beispiel `knopf` und `knopf2`, und ein eigenes `add`. Das FlowLayout stellt die Knöpfe in der Reihenfolge der `add`-Zeilen auf.
 :::

web/lessons/de/30-der-knopf-reagiert.md

@@ -294,6 +294,12 @@ Jetzt machst du die Aufgabe fertig: Baue ein Fenster mit einem Knopf „Klick mi
 
 Zusatz: Baue zwei Knöpfe „Rot“ und „Blau“. Ein Klick auf einen Knopf schreibt seinen Namen in den Titel des Fensters, zum Beispiel „Du hast Rot gewählt“.
 
+**Du bist fertig, wenn …**
+
+- vor dem Klick „Klick mich“ auf dem Knopf steht,
+- nach dem Klick „Ich wurde geklickt“ darauf steht,
+- der Knopf nicht das ganze Fenster füllt.
+
 ::: ludwig
 Jeder Knopf bekommt seinen eigenen Zuhörer mit eigenem `addActionListener`. Den Titel änderst du mit `fenster.setTitle(…)`.
 :::

web/lessons/de/31-zahl-verdoppeln.md

@@ -234,6 +234,12 @@ Baue das ganze Programm zusammen:
 
 Zusatz: Ein zweiter Knopf „Halbieren“ teilt die Zahl durch 2. Was passiert bei 5?
 
+**Du bist fertig, wenn …**
+
+- der Titel „Zahl verdoppeln“ heißt und Beschriftung, Textfeld und Knopf untereinander stehen,
+- aus 2 nach drei Klicks nacheinander 4, 8 und 16 werden,
+- bei „abc“ ein Hinweis in der Beschriftung steht und das Programm weiterläuft.
+
 ::: ludwig
 Der Knopf „Halbieren“ kommt als vierte Zeile ins GridLayout und bekommt seinen eigenen ActionListener. Bei `int` schneidet Java beim Teilen die Nachkommastellen ab.
 :::

web/lessons/de/32-klickzaehler.md

@@ -194,6 +194,12 @@ Baue den Klickzähler nach und erweitere ihn:
 - ein Knopf **−1**, der eins herunterzählt,
 - die Zahl soll nie unter 0 fallen. Steht sie auf 0, passiert bei −1 nichts.
 
+**Du bist fertig, wenn …**
+
+- **+1** eins hochzählt und **−1** eins herunterzählt,
+- bei 0 ein Klick auf **−1** nichts ändert,
+- **Reset** die Zahl wieder auf 0 setzt.
+
 ::: ludwig
 Für „nie unter 0“ brauchst du im Zuhörer von −1 ein `if`: Nur wenn `anzahl > 0` ist, wird heruntergezählt.
 :::

web/lessons/de/33-ampel.md

@@ -236,6 +236,12 @@ Baue die Ampel nach und mach sie echter. In Deutschland leuchten nach Rot kurz R
 
 Zusatz: Schreib in jeder Phase zusätzlich mit `licht.setText(…)`, was die Ampel bedeutet, zum Beispiel „Stehen“ oder „Gehen“.
 
+**Du bist fertig, wenn …**
+
+- jeder Klick die nächste Phase zeigt: Rot, Rot-Gelb (orange), Grün, Gelb,
+- nach Gelb wieder Rot kommt,
+- im Zusatz zu jeder Phase der passende Text steht.
+
 ::: ludwig
 Mit vier Phasen kommt nach 3 wieder 0. Pass also die Zahl in `if (phase > 2)` an.
 :::

web/lessons/de/34-notenrechner.md

@@ -236,6 +236,12 @@ Baue den Notenrechner zusammen, mit beiden Prüfungen aus dem letzten Schritt. T
 
 Zusatz: Schreib die Note zusätzlich als Wort hin, zum Beispiel „Note: 2 (gut)“. Die Wörter sind sehr gut, gut, befriedigend, ausreichend, mangelhaft und ungenügend.
 
+**Du bist fertig, wenn …**
+
+- 92 und 100 eine 1 ergeben, 91 eine 2 und 0 eine 6,
+- bei 101 der Hinweis „Bitte 0 bis 100 eingeben.“ erscheint,
+- bei „zehn“ ein Hinweis erscheint und das Programm weiterläuft.
+
 ::: ludwig
 Teste immer die Grenzen: 92 muss eine 1 sein, 91 eine 2. An den Grenzen stecken die meisten Fehler, zum Beispiel `>` statt `>=`.
 :::

web/lessons/de/35-taschenrechner.md

@@ -232,6 +232,12 @@ Baue den Rechner fertig:
 
 Zusatz: Ein fünfter Knopf **C** leert beide Felder und setzt das Ergebnis wieder auf „?“.
 
+**Du bist fertig, wenn …**
+
+- 7 und 2 bei +, −, * und / die Ergebnisse 9, 5, 14 und 3 zeigen,
+- 7 / 0 „Nicht durch 0!“ meldet,
+- bei „abc“ oder einem leeren Feld „Bitte zwei Zahlen eingeben“ erscheint und nichts abstürzt.
+
 ::: ludwig
 Für „abc“ brauchst du in jedem Zuhörer ein try/catch mit `NumberFormatException`. Hinter einem `try` dürfen auch zwei `catch` stehen, einer für `NumberFormatException` und einer für `ArithmeticException`. Ein leeres Feld liefert übrigens den Text `""`, und auch der ist keine Zahl.
 :::

web/lessons/de/36-zahlenraten.md

@@ -117,6 +117,12 @@ Baue das Spiel nach und mach es besser:
 
 Zusatz: Nach 7 Fehlversuchen ist das Spiel verloren. Das Fenster verrät dann die geheime Zahl.
 
+**Du bist fertig, wenn …**
+
+- du bei jedem falschen Tipp „zu klein“ oder „zu groß“ siehst,
+- „abc“ den Hinweis „Bitte eine Zahl eingeben“ bringt und die Versuche dabei gleich bleiben,
+- **Neues Spiel** die Versuche auf 0 setzt, den Knopf Raten wieder einschaltet und den Hinweis zurücksetzt.
+
 ::: ludwig
 Für „zählt nicht als Versuch“ muss `versuche++` **hinter** `Integer.parseInt` stehen, beides im `try`-Block. Wirft `parseInt` eine Exception, wird die Zeile mit `versuche++` übersprungen.
 :::

web/lessons/de/37-viele-knoepfe-ein-zuhoerer.md

@@ -260,6 +260,12 @@ Dann mach es besser:
 - Nach drei falschen Versuchen schaltet sich **OK** ab, wie der Knopf beim Zahlenraten in Lektion 36. Zähle die Versuche in einer `static int`-Variable in der Klasse.
 - Zusatz: Die Anzeige zeigt `*` statt der Ziffern. Merke dir die echte Eingabe in einer `static String eingabe = "";` und hänge an die Anzeige nur einen Stern an.
 
+**Du bist fertig, wenn …**
+
+- der richtige Code das Schloss öffnet und ein falscher nicht,
+- nach drei falschen Versuchen **OK** ausgeschaltet ist,
+- im Zusatz die Anzeige nur Sterne zeigt, der Code aber trotzdem geprüft wird.
+
 ::: ludwig
 Auch beim Taschenrechner aus Lektion 35 reicht ein Zuhörer für +, -, \* und /. Prüfe darin mit `e.getActionCommand().equals("+")`, welches Rechenzeichen geklickt wurde.
 :::

web/lessons/de/38-innere-klassen.md

@@ -191,6 +191,12 @@ Baue den Klickzähler mit drei Knöpfen:
 
 Probiere aus, ob alle drei Knöpfe wie erwartet zählen. Lass dann bei der Klasse `Plus` das `static` weg und lies die Fehlermeldung von javac.
 
+**Du bist fertig, wenn …**
+
+- **+1** hoch-, **-1** herunterzählt und **Reset** auf 0 setzt,
+- im Code genau eine benannte innere Klasse, eine anonyme Klasse und ein Lambda stehen,
+- du ohne `static` bei `Plus` die Fehlermeldung von javac gelesen hast und erklären kannst, was sie bedeutet.
+
 ## Checkliste
 
 Schätze dich bei jedem Punkt ehrlich ein: ☂️ noch nicht, ⛅ teilweise, ☀️ kann ich sicher. Bei ⛅ und ☂️ hilft dir **Nachlesen**. Danach kommt der Wissenstest. Er zeigt dir, ob deine Einschätzung stimmt.

web/lessons/de/39-zwei-reiter.md

@@ -240,6 +240,12 @@ Dann mach es besser:
 - Der Reiter Liste zeigt in seinem Titel, wie viele Dinge auf der Liste stehen: „Liste (3)“. Zähle in einer `static int`-Variable mit und benutze `setTitleAt`.
 - Zusatz: Ein dritter Reiter **Hilfe** mit einem JLabel, das erklärt, wie das Programm geht.
 
+**Du bist fertig, wenn …**
+
+- ein eingegebener Eintrag nach dem Klick im Reiter Liste steht,
+- ein leeres Feld nichts zur Liste hinzufügt,
+- der Reiter nach drei Einträgen „Liste (3)“ heißt.
+
 ## Checkliste
 
 Schätze dich bei jedem Punkt ehrlich ein: ☂️ noch nicht, ⛅ teilweise, ☀️ kann ich sicher. Bei ⛅ und ☂️ hilft dir **Nachlesen**. Danach kommt der Wissenstest. Er zeigt dir, ob deine Einschätzung stimmt.

web/lessons/de/40-model-view-controller.md

@@ -366,6 +366,13 @@ Dann mach es besser:
 - Das Model achtet selbst auf die Grenzen: nie unter 0 und nie über 10, denn dann ist der Balken voll.
 - Extra: eine dritte View `KonsolenAnzeige`, deren `aktualisieren` mit `System.out.println` „Neuer Wert: 3“ ausgibt. Eine View muss kein Fenster sein.
 
+**Du bist fertig, wenn …**
+
+- **+1**, **−1** und **Reset** richtig zählen,
+- der Zähler nie unter 0 und nie über 10 geht, egal wie oft du klickst,
+- Zahl und Balken immer denselben Wert zeigen,
+- in der Klasse des Model kein `JButton`, `JLabel` oder anderes Swing vorkommt.
+
 ## Checkliste
 
 Schätze dich bei jedem Punkt ehrlich ein: ☂️ noch nicht, ⛅ teilweise, ☀️ kann ich sicher. Bei ⛅ und ☂️ hilft dir **Nachlesen**. Danach kommt der Wissenstest. Er zeigt dir, ob deine Einschätzung stimmt.

web/lessons/de/visubot/00-struktogramm-und-editor.md

@@ -37,7 +37,7 @@ Jedes Programm, auch das für einen Roboter, besteht aus nur drei Bausteinen:
 | **Verzweigung** | je nach Bedingung das eine oder das andere | Ist die Wand nah? Dann drehen, sonst vorfahren. |
 | **Wiederholung** | Schritte mehrmals | viermal das Gleiche tun |
 
-Im Struktogramm sieht man die Bausteine sofort: Die Verzweigung hat oben ein Dreieck mit **Ja** und **Nein**. Die Wiederholung (Schleife) umschließt ihre Kästen wie ein gekipptes L.
+Im Struktogramm sieht man die Bausteine sofort: Die Verzweigung hat oben ein Dreieck und zwei Spalten: links **true** (wahr), rechts **false** (falsch). Die Wiederholung (Schleife) umschließt ihre Kästen wie ein gekipptes L.
 
 ::: diagramm vb-l00-bausteine-loesung.visustruct
 Alle drei Bausteine: erst ein Kasten, dann eine Schleife, darin eine Verzweigung.
@@ -69,6 +69,8 @@ tipp: Von oben nach unten: **fahre vor**, **drehe rechts**, **fahre vor**, **dre
 lösung: vb-erster-plan-loesung.visustruct
 :::
 
+> Bist du fertig, klickst du in der Übung auf **Prüfen**. VisuStruct lässt dein Struktogramm dann laufen und schaut nach, ob der mBot2 genau so fährt wie verlangt. Später prüft es dein Programm oft in mehreren Welten, zum Beispiel einmal mit Wand und einmal ohne. Klappt es nicht, helfen dir die **Tipps**.
+
 ## Speichern und Öffnen
 
 - **[Speichern](#zeige-speichern)** (Strg+S, am Mac ⌘S): Das Struktogramm wird als Datei mit der Endung `.visustruct` gespeichert. Den Dateinamen schlägt der [Titel](#zeige-titel) über dem Struktogramm vor.
@@ -183,7 +185,7 @@ Schätze dich bei jedem Punkt ehrlich ein: ☂️ noch nicht, ⛅ teilweise, ☀
 - [ ] die Sequenz
 - [x] die Verzweigung
 - [ ] die Wiederholung
-> Die Verzweigung hat oben ein Dreieck mit Ja und Nein.
+> Die Verzweigung hat oben ein Dreieck und zwei Spalten für true und false.
 ? Du ziehst **fahre vor** auf die untere Hälfte eines Kastens. Wo landet es?
 → Der Editor
 - [ ] davor

web/lessons/de/visubot/02-das-quadrat.md

@@ -41,6 +41,21 @@ Ziehe eine For-Schleife ins Struktogramm und gib ihr diese drei Teile:
 
 In den Inhalt der Schleife kommt ein einziges **fahre vor**. Die Schleife zählt `i` von 0 bis 4, das sind fünf Durchläufe.
 
+`i` ist ein **Zähler**. Der Computer merkt sich darin, im wievielten Durchlauf er gerade ist. So einen Speicher mit Namen nennt man **Variable**, genauer lernst du sie in Lektion 3 kennen. Die drei Teile bedeuten:
+
+| Teil | Bedeutung |
+|---|---|
+| `int i = 0` | Der Zähler `i` ist eine ganze Zahl (`int`) und fängt bei 0 an. |
+| `i < 5` | Solange `i` kleiner als 5 ist, läuft die Schleife noch einmal. |
+| `i++` | Nach jedem Durchlauf wird `i` um 1 größer. |
+
+So zählt die Schleife:
+
+| Durchlauf | 1 | 2 | 3 | 4 | 5 | danach |
+|---|---|---|---|---|---|---|
+| `i` | 0 | 1 | 2 | 3 | 4 | 5 |
+| `i < 5`? | true | true | true | true | true | false, fertig |
+
 ::: übung vb-quadrat-schleife
 titel: Seiten mit Schleife
 auftrag: Ersetze in deinem Quadrat jede Reihe aus fünf **fahre vor** durch eine For-Schleife, die fünfmal fährt. Der mBot2 fährt danach genau dasselbe Quadrat.