Skip to content
This repository was archived by the owner on Nov 7, 2026. It is now read-only.

Commit 709fca0

Browse files
Web 0.5.0: VisuStruct oder VisuBot (zwei Welten) und VisuBot-Grundlagen mit Roboter (#158, enthält #157)
* VisuStruct oder VisuBot: zwei getrennte Welten, Wahl im Start-Dialog und Zahnrad, Welt in der Adresse Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K8C1HvVqFVDDiMJ5WasFzi * VisuBot-Grundlagen mit Roboter: fünf neue Lektionen mit „Jetzt ohne Roboter“ Neue VisuBot-Lektionen 3 Variablen und Ausgabe, 9 Fallauswahl mit Farben, 17 Arrays und Melodien, 19 Zeichenketten und 22 Eigene Methoden (de/en). Jede endet mit einer reinen Java-Übung ohne mbot. Die übrigen Lektionen rücken auf, progress.ts übernimmt den Lernstand. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K8C1HvVqFVDDiMJ5WasFzi * Web 0.5.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K8C1HvVqFVDDiMJ5WasFzi --------- Co-authored-by: Claude <noreply@anthropic.com>
1 parent b00dad9 commit 709fca0

172 files changed

Lines changed: 4015 additions & 3527 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎CHANGELOG.md‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,8 @@ The format is loosely inspired by Keep a Changelog.
88

99
### Added
1010

11+
- **Web 0.5.0, VisuBot basics with the robot:** five new VisuBot lessons teach the Java basics with the mBot2 as the example: 3 “Variables and output”, 9 “Case selection with colours”, 17 “Arrays and melodies”, 19 “Strings” and 22 “Your own methods” (de/en). Each has a structogram exercise, a Java exercise and ends with “Now without the robot”: plain Java with console output and no `mbot`, because real Java is the goal. The other VisuBot lessons move to 4–8, 10–16, 18, 20 and 21; learning progress is carried over.
12+
- **Web 0.5.0, VisuStruct or VisuBot:** two separate worlds instead of the VisuBot modes Off / In the course / Separate series. VisuStruct shows the course without any robot; VisuBot shows only the robot lessons, robot tasks and the mBot2 reference. You choose at the top of the start dialog or the gear menu. The address shows `?visubot` or `?visustruct`, so a link opens the right world. The 🤖 course steps of “In the course” were removed (a saved “In the course” now opens VisuBot). The website's lesson links open VisuStruct.
1113
- **Web 0.4.7, Programming:** a book button in the Programming header opens the reference (commands and terms) in the learning area, also when only Programming is open.
1214
- **Web 0.4.7, VisuBot colour sensor:** `mbot.getColor()` gives the colour under the mBot2 as text (“rot”/“red”, “grün”/“green”, “blau”, “gelb”, “schwarz”, “weiß”, in the language of the lessons) and replaces `isRed()`, `isGreen()`, `isBlue()` and `isYellow()`. Conditions are written as `mbot.getColor().equals("rot")`; lesson 7 explains why texts are compared with `.equals` and not `==`. Course steps, tasks, model solutions and the reference were updated. Confirmed on a real mBot2 (red, white, black).
1315
- **Web 0.4.5, VisuBot in the course:** with VisuBot “In the course”, the VisuBot tour comes first as lesson 0 (same learning progress as in the separate series). The robot steps are now called “🤖 Now with VisuBot: …”. New LED steps: a running light in lesson 13 (for loop) and a rainbow colour array in lesson 15 (arrays).
Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
1+
---
2+
titel: Variablen und Ausgabe
3+
bereich: VisuBot
4+
kurz: Werte in Variablen speichern, den mBot2 damit fahren lassen und Ergebnisse ausgeben.
5+
---
6+
7+
## Eine Variable für die Seite
8+
9+
Mit `mbot.forward(30)` fährt der mBot2 30 cm am Stück. Fährst du damit ein Quadrat ohne Schleife, steht die 30 aber viermal im Programm. Soll das Quadrat größer werden, musst du sie an vier Stellen ändern. Besser ist es, die Seitenlänge **einmal** zu speichern und dann überall zu benutzen.
10+
11+
Dafür gibt es **Variablen**. Eine Variable ist ein Kästchen mit einem Namen, in dem ein Wert liegt:
12+
13+
```java
14+
int seite = 30;
15+
mbot.forward(seite);
16+
```
17+
18+
- `int` ist der **Datentyp**: eine ganze Zahl.
19+
- `seite` ist der **Name**. Du darfst ihn selbst wählen.
20+
- `30` ist der **Wert**. Das `=` legt ihn in das Kästchen.
21+
22+
Wo danach `seite` steht, setzt der Computer den Wert ein. `mbot.forward(seite)` fährt also 30 cm.
23+
24+
::: übung vb-variable-seite
25+
titel: Quadrat mit Variable
26+
auftrag: Lege in einer Anweisung die Variable `int seite = 30` an. Danach fährt der mBot2 ein Quadrat: viermal `seite` Zentimeter vor und nach rechts drehen.
27+
fahrt: 4 x (forward 30, turnRight)
28+
braucht: forSchleife
29+
tipp: Die erste Anweisung ist `int seite = 30`. Darunter kommt eine For-Schleife, die viermal läuft.
30+
tipp: In der Schleife stehen `mbot.forward(seite)` und `mbot.turnRight()`.
31+
lösung: vb-variable-seite-loesung.visustruct
32+
:::
33+
34+
> Ändere jetzt nur die 30 in eine 60 und starte die Simulation. Das ganze Quadrat wird doppelt so groß.
35+
36+
## Welche Datentypen gibt es?
37+
38+
Jede Variable hat einen Datentyp. Er legt fest, welche Werte hineinpassen:
39+
40+
| Datentyp | Was passt hinein? | Beispiel |
41+
|---|---|---|
42+
| `int` | ganze Zahlen | `int seite = 30;` |
43+
| `double` | Kommazahlen, mit Punkt geschrieben | `double tempo = 1.5;` |
44+
| `String` | Text in Anführungszeichen | `String name = "Visu";` |
45+
| `boolean` | wahr oder falsch | `boolean fertig = false;` |
46+
47+
Mit Variablen kannst du auch rechnen: `int strecke = 4 * seite;` rechnet die ganze Strecke des Quadrats aus.
48+
49+
## Jetzt in Java: Rechteck
50+
51+
Ein Rechteck hat zwei verschiedene Seiten. Also brauchst du zwei Variablen.
52+
53+
::: übung vb-java-rechteck
54+
titel: Rechteck mit Variablen
55+
code: java
56+
auftrag: Schreibe in Java: Lege `int laenge = 60` und `int breite = 30` an. Der mBot2 fährt ein Rechteck: Länge, rechts drehen, Breite, rechts drehen, und das zweimal.
57+
fahrt: 2 x (forward 60, turnRight, forward 30, turnRight)
58+
braucht: forSchleife
59+
tipp: Zwei Variablen oben: `int laenge = 60;` und `int breite = 30;`. Darunter eine For-Schleife, die zweimal läuft.
60+
tipp: In der Schleife: `mbot.forward(laenge);`, `mbot.turnRight();`, `mbot.forward(breite);`, `mbot.turnRight();`
61+
lösung: vb-java-rechteck-loesung.visustruct
62+
:::
63+
64+
## Jetzt ohne Roboter: Ausgabe
65+
66+
Nicht jedes Ergebnis muss der Roboter fahren. Mit `System.out.println(…)` gibt ein Java-Programm Text in der [Konsole](#zeige-konsole) aus. Mit `+` hängst du Text und Werte aneinander:
67+
68+
```java
69+
int seite = 30;
70+
int strecke = 4 * seite;
71+
System.out.println("Strecke: " + strecke + " cm");
72+
```
73+
74+
Die Konsole zeigt dann **Strecke: 120 cm**.
75+
76+
::: übung vb-ohne-strecke
77+
titel: Wie weit fährt er?
78+
code: java
79+
auftrag: Ein Rechteck ist 60 cm lang und 30 cm breit. Lege `laenge` und `breite` als Variablen an. Berechne in einer Variablen `strecke`, wie weit der mBot2 einmal ganz herum fährt, und gib **Strecke: 180 cm** aus. Ganz ohne `mbot`!
80+
test: - -> Strecke: 180 cm
81+
braucht: anweisung
82+
tipp: Einmal herum sind zweimal die Länge und zweimal die Breite.
83+
tipp: `int strecke = 2 * laenge + 2 * breite;` und dann `System.out.println("Strecke: " + strecke + " cm");`
84+
lösung: vb-ohne-strecke-loesung.visustruct
85+
:::
86+
87+
::: quiz
88+
? Was fährt `mbot.forward(seite)`, wenn vorher `int seite = 40;` steht?
89+
- [ ] 4 cm
90+
- [x] 40 cm
91+
- [ ] gar nichts, `seite` ist kein Befehl
92+
> Wo `seite` steht, setzt Java den Wert 40 ein.
93+
? Welcher Datentyp passt zu `"Visu"`?
94+
- [ ] `int`
95+
- [ ] `double`
96+
- [x] `String`
97+
> Text in Anführungszeichen ist ein `String`.
98+
? Was gibt `System.out.println("Seite: " + 30);` aus?
99+
- [x] Seite: 30
100+
- [ ] "Seite: " + 30
101+
- [ ] 30
102+
> Das `+` hängt den Text und die Zahl aneinander.
103+
:::
104+
105+
::: checkliste
106+
- Ich kann eine Variable anlegen und benutzen. → Eine Variable für die Seite
107+
- Ich kenne die Datentypen `int`, `double`, `String` und `boolean`. → Welche Datentypen gibt es?
108+
- Ich kann mit zwei Variablen ein Rechteck in Java fahren. → Jetzt in Java: Rechteck
109+
- Ich kann mit `System.out.println` etwas ausgeben. → Jetzt ohne Roboter: Ausgabe
110+
:::
Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ Jetzt kommen die **Sensoren** dazu. Unter den [Elementen](#zeige-elemente) gibt
1515
| Abstand | `mbot.getDistance()` | Abstand bis zur nächsten Wand in cm, z. B. `38` |
1616
| Linie | `mbot.getLine()` | `0`, wenn unter dem Liniensensor alles hell ist, sonst eine Zahl größer als 0 |
1717

18-
Der mBot2 hat noch mehr Sensoren: Farben, Tasten und Joystick, Licht, Lautstärke und Neigung. Jeden lernst du in den Lektionen 5 bis 11 einzeln kennen, die Motoren in Lektion 16 und Stoppuhr und Akku in Lektion 17.
18+
Der mBot2 hat noch mehr Sensoren: Farben, Tasten und Joystick, Licht, Lautstärke und Neigung. Jeden lernst du in den Lektionen 6 bis 13 einzeln kennen, die Motoren in Lektion 20 und Stoppuhr und Akku in Lektion 21.
1919

2020
Ein Sensor ist **kein eigener Kasten**. Er liefert eine Zahl, und mit der baust du eine **Bedingung**:
2121

File renamed without changes.
File renamed without changes.
Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
1+
---
2+
titel: Fallauswahl mit Farben
3+
bereich: VisuBot
4+
kurz: Je nach Farbe oder Linie etwas anderes tun, mit einer Fallauswahl statt vieler Verzweigungen.
5+
---
6+
7+
## Viele Farben, viele Fälle
8+
9+
Der mBot2 soll auf jede Farbe anders reagieren: bei Rot rechts abbiegen, bei Grün ein Stück vorfahren, bei Blau piepen. Mit Verzweigungen bräuchtest du drei ineinander. Übersichtlicher ist die **Fallauswahl**, in Java `switch`:
10+
11+
```java
12+
switch (mbot.getColor()) {
13+
case "rot" -> {
14+
mbot.turnRight();
15+
}
16+
case "grün" -> {
17+
mbot.forward(20);
18+
}
19+
default -> {
20+
mbot.forward(10);
21+
}
22+
}
23+
```
24+
25+
- Oben in den Klammern steht der Wert, der geprüft wird, hier die Farbe.
26+
- Jeder `case` ist ein **Fall**. Passt der Wert, läuft genau dieser Fall.
27+
- `default` ist der Fall für **alles andere**.
28+
29+
Im Struktogramm ist die Fallauswahl ein Kasten mit mehreren Spalten, für jeden Fall eine.
30+
31+
::: übung vb-farbweiche
32+
titel: Farbweiche
33+
auftrag: Baue eine Fallauswahl über `mbot.getColor()`. Bei `"rot"` dreht sich der mBot2 nach rechts. Bei `"grün"` fährt er 20 cm vor. Bei `"blau"` spielt er einen Ton mit 880 Hertz, 200 Millisekunden lang. In allen anderen Fällen fährt er 10 cm vor.
34+
messwerte: getColor=rot -> turnRight
35+
messwerte: getColor=grün -> forward 20
36+
messwerte: getColor=blau -> none, tone
37+
messwerte: getColor=weiß -> forward 10
38+
braucht: fallauswahl
39+
tipp: Zieh eine Fallauswahl ins Struktogramm. Oben steht `mbot.getColor()`, die Fälle heißen `"rot"`, `"grün"` und `"blau"`, dazu der Fall für alles andere.
40+
tipp: Bei Rot `mbot.turnRight()`, bei Grün `mbot.forward(20)`, bei Blau `mbot.playTone(880, 200)`, sonst `mbot.forward(10)`.
41+
lösung: vb-farbweiche-loesung.visustruct
42+
:::
43+
44+
## Jetzt in Java: Linienmuster
45+
46+
Auch eine Zahl kann der Wert einer Fallauswahl sein. `mbot.getLine()` aus Lektion 7 liefert zum Beispiel:
47+
48+
| Wert | Bedeutung |
49+
|---|---|
50+
| `0` | keine Linie |
51+
| `6` | die beiden mittleren Fühler sehen die Linie: Er steht genau drauf |
52+
| `15` | alle vier sehen Schwarz: eine Querlinie |
53+
54+
Bei Zahlen schreibst du den Fall ohne Anführungszeichen: `case 6 -> { … }`.
55+
56+
::: übung vb-linienmuster
57+
titel: Linienmuster
58+
code: java
59+
auftrag: Schreibe in Java eine Fallauswahl über `mbot.getLine()`. Bei 6 fährt der mBot2 10 cm vor. Bei 0 dreht er sich nach rechts. Bei 15 zeigt er **Querlinie!** auf dem Bildschirm. In allen anderen Fällen fährt er 5 cm vor.
60+
messwerte: getLine=6 -> forward 10
61+
messwerte: getLine=0 -> turnRight
62+
messwerte: getLine=15 -> none, screen "Querlinie!"
63+
messwerte: getLine=4 -> forward 5
64+
braucht: fallauswahl
65+
tipp: `switch (mbot.getLine()) { case 6 -> { … } case 0 -> { … } case 15 -> { … } default -> { … } }`
66+
tipp: Bei 6 `mbot.forward(10);`, bei 0 `mbot.turnRight();`, bei 15 `mbot.showText("Querlinie!");`, sonst `mbot.forward(5);`.
67+
lösung: vb-linienmuster-loesung.visustruct
68+
:::
69+
70+
## Jetzt ohne Roboter: Noten in Worten
71+
72+
Die Fallauswahl brauchst du nicht nur für Roboter. Dieses Programm liest eine Zahl ein, die der Benutzer in der [Konsole](#zeige-konsole) tippt:
73+
74+
```java
75+
Scanner scanner = new Scanner(System.in);
76+
int note = scanner.nextInt();
77+
```
78+
79+
::: übung vb-ohne-noten
80+
titel: Noten in Worten
81+
code: java
82+
auftrag: Lies eine Note als Zahl ein. Gib bei 1 **sehr gut** aus, bei 2 **gut**, bei 3 **befriedigend** und bei allen anderen Zahlen **andere Note**. Ganz ohne `mbot`!
83+
test: 1 -> sehr gut
84+
test: 2 -> gut
85+
test: 3 -> befriedigend
86+
test: 5 -> andere Note
87+
braucht: fallauswahl
88+
tipp: Zuerst `Scanner scanner = new Scanner(System.in);` und `int note = scanner.nextInt();`. Danach kommt `switch (note) { … }`.
89+
tipp: `case 1 -> { System.out.println("sehr gut"); }` und so weiter, zum Schluss `default -> { System.out.println("andere Note"); }`.
90+
lösung: vb-ohne-noten-loesung.visustruct
91+
:::
92+
93+
::: quiz
94+
? Der mBot2 steht auf Gelb. Welcher Fall der Farbweiche läuft?
95+
- [ ] der Fall `"rot"`
96+
- [ ] gar keiner
97+
- [x] `default`
98+
> Für Gelb gibt es keinen eigenen Fall. Dann läuft der Fall für alles andere.
99+
? Wie schreibst du den Fall für die Zahl 6?
100+
- [x] `case 6 -> { … }`
101+
- [ ] `case "6" -> { … }`
102+
- [ ] `if 6 -> { … }`
103+
> Zahlen stehen ohne Anführungszeichen, Texte wie `"rot"` mit.
104+
:::
105+
106+
::: checkliste
107+
- Ich kann eine Fallauswahl mit Texten bauen. → Viele Farben, viele Fälle
108+
- Ich kann eine Fallauswahl mit Zahlen in Java schreiben. → Jetzt in Java: Linienmuster
109+
- Ich kann eine Zahl einlesen und je nach Wert etwas ausgeben. → Jetzt ohne Roboter: Noten in Worten
110+
:::
File renamed without changes.
File renamed without changes.

0 commit comments

Comments
 (0)