Willkommen bei der Rustanleitung!

Hallo und herzlich willkommen! 👋

Diese Anleitung hilft dir dabei, das Programmieren zu lernen – und zwar mit der Programmiersprache Rust und einer besonderen Hilfe: der Schildkröten-Grafik (englisch: Turtle Graphics).

Für wen ist diese Anleitung?

Diese Anleitung ist für alle, die:

Noch nie programmiert haben
Neugierig sind, wie Programmieren funktioniert
Gerne etwas Neues lernen möchten
Spaß daran haben, mit dem Computer kreativ zu sein

Du brauchst keine Vorkenntnisse – wir fangen ganz von vorne an!

Was wirst du lernen?

In dieser Anleitung wirst du lernen:

Was Programmieren überhaupt ist
Wie man einfache Programme schreibt
Wie man mit der Schildkröte bunte Bilder zeichnet
Grundlegende Konzepte der Programmierung wie Wiederholungen, Variablen und Funktionen

Die Schildkröten-Grafik ist eine besondere Art, das Programmieren zu lernen. Du stellst dir vor, dass eine kleine Schildkröte über den Bildschirm läuft und dabei mit einem Stift eine Spur hinterlässt. Du kannst der Schildkröte Befehle geben wie:

“Gehe 100 Schritte vorwärts”
“Drehe dich 90 Grad nach rechts”
“Wechsle die Farbe zu Blau”

So entstehen nach und nach Bilder und Muster!

Los geht’s!

Bist du bereit? Dann lass uns anfangen! 🚀

Im nächsten Kapitel richten wir gemeinsam deine Programmierumgebung ein, damit du direkt loslegen kannst.

Einrichtung der Programmierumgebung

Bevor wir mit dem Programmieren beginnen können, müssen wir ein paar Programme auf deinem Computer installieren. Keine Sorge – wir gehen das Schritt für Schritt durch!

Was brauchen wir?

Rust – Die Programmiersprache, die wir verwenden
Visual Studio Code – Ein Programm, in dem wir unseren Code schreiben (wird “Editor” genannt)
Erweiterungen für VS Code – Zusätzliche Funktionen, die uns beim Programmieren helfen

Schritt 1: Rust installieren

Rust ist die Programmiersprache, mit der wir arbeiten werden. Zusammen mit Rust wird auch Cargo installiert – ein Werkzeug, das uns bei der Verwaltung unserer Programme hilft.

Installation auf Windows

Gehe zu https://rustup.rs/
Lade die Installationsdatei herunter
Führe die Datei aus und folge den Anweisungen
Wenn du gefragt wirst, wähle die Standardinstallation (Option 1)

Installation auf macOS oder Linux

Öffne das Terminal

Kopiere diesen Befehl und drücke Enter:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Folge den Anweisungen auf dem Bildschirm
Wähle die Standardinstallation (Option 1)

Installation überprüfen

Um zu prüfen, ob die Installation geklappt hat:

Öffne ein neues Terminal oder eine neue Eingabeaufforderung
Tippe cargo --version und drücke Enter
Du solltest eine Versionsnummer sehen, z.B. cargo 1.92.0

Schritt 2: Visual Studio Code installieren

Visual Studio Code (kurz: VS Code) ist ein kostenloses Programm, in dem wir unseren Code schreiben.

Gehe zu https://code.visualstudio.com/
Lade VS Code für dein Betriebssystem herunter
Installiere das Programm
Starte VS Code

Schritt 3: Wichtige Erweiterungen installieren

Erweiterungen sind wie Apps für VS Code – sie fügen nützliche Funktionen hinzu. Wir brauchen zwei wichtige Erweiterungen:

rust-analyzer

Diese Erweiterung hilft dir beim Schreiben von Rust-Code. Sie zeigt Fehler an, schlägt Code vor und erklärt Befehle.

Installation:

Klicke in VS Code auf das Erweiterungs-Symbol in der linken Leiste (vier Quadrate)
Suche nach rust-analyzer
Klicke auf “Installieren”

CodeLLDB

Diese Erweiterung ermöglicht es, deine Programme zu starten und zu testen.

Installation:

Suche im Erweiterungs-Bereich nach CodeLLDB
Klicke auf “Installieren”

Schritt 4: Projekt einrichten

Jetzt erstellen wir unser erstes Projekt!

1. Projekt-Ordner erstellen

Wähle einen Ort auf deinem Computer, wo du deine Programmier-Projekte speichern möchtest, z.B. in deinem Dokumente-Ordner.

2. Projekt mit Cargo erstellen

Öffne das Terminal in VS Code (Menü: Terminal → Neues Terminal)
Gehe zu dem Ordner, wo du dein Projekt erstellen möchtest:
```
cd ~/Dokumente
```

Erstelle ein neues Projekt:

cargo new mein-turtle-projekt
cd mein-turtle-projekt

Cargo hat jetzt automatisch einen Ordner mit allem erstellt, was du brauchst!

3. Turtle-Bibliothek hinzufügen

Öffne die Datei Cargo.toml in deinem Projekt-Ordner. Das ist die Konfigurationsdatei für dein Projekt.

Füge unter [dependencies] folgende Zeilen hinzu:

[dependencies]
turtle-lib = { git = "https://github.com/enaut/turtlers", package = "turtle-lib" }
macroquad = "0.4"

Deine Cargo.toml sollte jetzt ungefähr so aussehen:

[package]
name = "mein-turtle-projekt"
version = "0.1.0"
edition = "2021"

[dependencies]
turtle-lib = { git = "https://github.com/enaut/turtlers", package = "turtle-lib" }
macroquad = "0.4"

4. Projekt in VS Code öffnen

In VS Code: Menü → Datei → Ordner öffnen
Wähle den Ordner mein-turtle-projekt
VS Code lädt jetzt das Projekt

Schritt 5: Dein erstes Programm schreiben

Öffne die Datei src/main.rs im Projekt-Ordner
Ersetze den Inhalt mit diesem Code:

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(BLUE);
    turtle.forward(100.0);
    turtle.right(90.0);
    turtle.forward(100.0);
}

Speichere die Datei (Strg+S oder Cmd+S)

Schritt 6: Programm starten

Es gibt mehrere Möglichkeiten, dein Programm zu starten:

Methode 1: Run-Button (empfohlen)

Über der fn main() Zeile siehst du kleine Schaltflächen: Run | Debug

Klicke auf Run
Warte, während das Programm kompiliert wird (beim ersten Mal dauert es etwas länger)
Ein Fenster öffnet sich und zeigt deine Zeichnung!

Methode 2: Terminal

Im Terminal von VS Code:

cargo run

Methode 3: Beispiele ausführen

Später werden wir mit Beispielen arbeiten. Diese startest du so:

cargo run --example quadrat

Was ist Cargo?

Cargo ist das Werkzeug, das alle Rust-Entwickler verwenden. Es hilft dir dabei:

Neue Projekte zu erstellen (cargo new)
Programme zu kompilieren und auszuführen (cargo run)
Bibliotheken zu verwalten (wie unsere turtle-lib)
Code zu überprüfen (cargo check)

Wo finde ich Rust-Bibliotheken?

Wenn du später weitere Rust-Bibliotheken nutzen möchtest, findest du diese auf:

crates.io – Das offizielle Repository für Rust-Bibliotheken
Dort kannst du nach Bibliotheken suchen und sie deinem Projekt hinzufügen

Häufige Probleme

“rust-analyzer funktioniert nicht”

Stelle sicher, dass Rust richtig installiert ist (cargo --version im Terminal)
Starte VS Code neu
Öffne VS Code über “Ordner öffnen” (nicht einzelne Dateien)

“Das Programm kompiliert nicht”

Überprüfe, ob Cargo.toml die richtigen Dependencies hat
Schau dir die Fehlermeldungen im Terminal genau an
rust-analyzer zeigt Fehler auch im Editor mit roten Wellenlinien an

“Das Fenster öffnet sich nicht”

Warte einen Moment – beim ersten Mal dauert es länger
Schau ins Terminal, ob Fehlermeldungen erscheinen

Zusammenfassung

Du hast jetzt:

✅ Rust und Cargo installiert
✅ VS Code mit wichtigen Erweiterungen eingerichtet
✅ Dein erstes Projekt erstellt
✅ Die Turtle-Bibliothek hinzugefügt
✅ Gelernt, wie du Programme startest

Perfekt! Deine Programmierumgebung ist jetzt einsatzbereit. Im nächsten Kapitel erfährst du, was Programmieren eigentlich ist und warum die Schildkröten-Grafik dir dabei hilft, es zu lernen.

Was ist Programmieren?

Computer können nur Befehle ausführen

Computer sind sehr schnelle Maschinen, aber sie sind nicht besonders schlau. Sie können nur genau das tun, was man ihnen sagt. Programmieren bedeutet, dem Computer eine Liste von Befehlen zu geben, die er dann Schritt für Schritt ausführt.

Stell dir vor, du erklärst jemandem, wie man ein Sandwich macht:

Nimm zwei Scheiben Brot
Bestreiche eine Scheibe mit Butter
Lege Käse darauf
Lege die zweite Scheibe Brot obendrauf

Das ist wie ein kleines Programm! Jeder Schritt ist eine Anweisung, die nacheinander ausgeführt wird.

Ein Programm ist eine Anleitung

Ein Programm ist nichts anderes als eine Anleitung für den Computer. Diese Anleitung schreibst du in einer besonderen Sprache – einer Programmiersprache. In unserem Fall verwenden wir die Programmiersprache Rust.

Computer verstehen keine normale menschliche Sprache wie Deutsch oder Englisch. Deshalb brauchen wir eine Programmiersprache, die sehr genau und eindeutig ist.

Was ist Rust?

Rust ist eine moderne Programmiersprache, die dafür bekannt ist, dass sie:

Sicher ist (weniger Fehler)
Schnell läuft
Beim Lernen hilft, gute Programme zu schreiben

Rust wird heute von vielen Firmen und Entwicklern auf der ganzen Welt verwendet, zum Beispiel bei Microsoft, Amazon und vielen anderen.

Warum mit der Schildkröte lernen?

Die Schildkröten-Grafik macht das Programmieren lernen besonders einfach, weil:

Du sofort siehst, was dein Programm macht
Es Spaß macht, bunte Bilder zu erzeugen
Die Befehle einfach und verständlich sind
Du kreativ sein kannst

Anstatt nur Text auf dem Bildschirm zu sehen, kannst du richtige Zeichnungen erstellen!

Bereit für dein erstes Programm?

Jetzt weißt du, was Programmieren ist und warum Rust eine tolle Sprache dafür ist. Im nächsten Kapitel wird es praktisch: Wir schreiben gemeinsam dein erstes Programm und lassen die Schildkröte einfache Formen zeichnen!

Dein erstes Programm

Jetzt wird es spannend! Du hast gelernt, was Programmieren ist und dass Rust die Sprache ist, mit der wir arbeiten. Jetzt wird es praktisch: Wir schreiben unser erstes Programm. Die Schildkröte soll einfache Linien zeichnen und daraus ein L bilden.

Wo schreibst du den Code?

Wenn du den Anweisungen aus Kapitel 0 (Einrichtung) gefolgt bist, hast du bereits ein Projekt erstellt. Jetzt öffnest du die Datei src/main.rs in deinem Projekt-Ordner – dort schreibst du dein Programm hinein.

Wichtig: Die Datei src/main.rs ist die Hauptdatei deines Projekts. Hier beginnt dein Programm, wenn du es startest.

Mehrere Programme im gleichen Projekt (optional)

Später möchtest du vielleicht mehrere verschiedene Programme ausprobieren, ohne das vorherige zu überschreiben. Dafür kannst du zusätzliche Programmdateien im Ordner src/bin/ erstellen:

Erstelle einen Ordner bin in deinem src-Verzeichnis (falls er noch nicht existiert)
Lege dort neue Dateien an, z.B. src/bin/mein_programm.rs
Starte sie mit: cargo run --bin mein_programm

Für den Anfang reicht aber src/main.rs vollkommen aus!

Das erste Programm

Hier ist der Code für unser erstes Programm:

//! Erstes Beispiel: Einfache Linien zeichnen
//!
//! Dieses Programm zeichnet ein einfaches L auf dem Bildschirm.

use turtle_lib::*;

#[turtle_main]
fn main() {
    // Setze die Stiftfarbe auf Blau
    turtle.set_pen_color(BLUE);
    
    // Zeichne eine Linie nach rechts
    turtle.forward(100.0);
    
    // Drehe nach unten
    turtle.right(90.0);
    
    // Zeichne eine Linie nach unten
    turtle.forward(100.0);
}

Ergebnis: Ein blaues L

Was passiert hier?

Lass uns das Programm Schritt für Schritt durchgehen:

1. Die erste Zeile

use turtle_lib::*;

Diese Zeile sagt dem Computer: “Ich möchte die Schildkröten-Bibliothek verwenden.” Eine Bibliothek ist eine Sammlung von fertigen Befehlen, die wir nutzen können. So müssen wir nicht alles selbst programmieren.

2. Die Hauptfunktion

#[turtle_main]
fn main() {
    // Hier steht unser Code
}

Jedes Rust-Programm hat eine main-Funktion (englisch für “Haupt”). Das ist der Startpunkt des Programms – hier beginnt der Computer mit der Ausführung.

Das #[turtle_main] darüber ist eine spezielle Anweisung, die das Fenster für die Schildkröte vorbereitet.

Tipp: Über der Zeile fn main() siehst du in VS Code einen Run-Button. Damit kannst du das Programm starten!

3. Die Stiftfarbe setzen

turtle.set_pen_color(BLUE);

Hier sagen wir der Schildkröte: “Verwende die Farbe Blau zum Zeichnen.” turtle ist unsere Schildkröte und set_pen_color ist der Befehl, um die Farbe zu ändern.

4. Die erste Linie zeichnen

turtle.forward(100.0);

Dieser Befehl sagt der Schildkröte: “Gehe 100 Schritte vorwärts.” Dabei zeichnet sie eine Linie.

5. Drehen

turtle.right(90.0);

Jetzt dreht sich die Schildkröte 90 Grad nach rechts. Sie schaut jetzt nach unten!

6. Die zweite Linie zeichnen

turtle.forward(100.0);

Die Schildkröte geht wieder 100 Schritte vorwärts – jetzt entsteht eine Linie nach unten.

Das Ergebnis ist ein L!

Programm starten

So startest du dein Programm:

Run-Button verwenden (einfachste Methode):
- Klicke auf Run über der fn main() Zeile
- Warte einen Moment (beim ersten Mal dauert es etwas länger)
- Ein Fenster öffnet sich und zeigt deine Zeichnung!
Terminal verwenden:
- Öffne das Terminal in VS Code
- Tippe cargo run und drücke Enter

Was siehst du?

Wenn du das Programm ausführst, öffnet sich ein Fenster. Darin siehst du:

Eine kleine Schildkröte (oft als Dreieck dargestellt)
Die Schildkröte bewegt sich und zeichnet dabei
Am Ende siehst du ein blaues L!

Ein Quadrat zeichnen

Jetzt wollen wir etwas Anspruchsvolleres zeichnen: ein Quadrat! Ein Quadrat hat vier gleich lange Seiten. Wir müssen also viermal das Gleiche machen: vorwärts gehen und nach rechts drehen.

//! Beispiel: Ein Quadrat zeichnen (ohne Schleife)
//!
//! Dieses Programm zeichnet ein einfaches Quadrat auf dem Bildschirm.

use turtle_lib::*;

#[turtle_main]
fn main() {
    // Setze die Stiftfarbe auf Blau
    turtle.set_pen_color(BLUE);
    
    // Zeichne die erste Seite
    turtle.forward(100.0);  // Gehe 100 Schritte vorwärts
    turtle.right(90.0);     // Drehe 90 Grad nach rechts
    
    // Zeichne die zweite Seite
    turtle.forward(100.0);
    turtle.right(90.0);
    
    // Zeichne die dritte Seite
    turtle.forward(100.0);
    turtle.right(90.0);
    
    // Zeichne die vierte Seite
    turtle.forward(100.0);
    turtle.right(90.0);
}

Ergebnis: Ein blaues Quadrat

Hier wiederholen wir den Code viermal:

Erste Seite: vorwärts, dann rechts drehen
Zweite Seite: vorwärts, dann rechts drehen
Dritte Seite: vorwärts, dann rechts drehen
Vierte Seite: vorwärts, dann rechts drehen

Das funktioniert, aber du siehst: Der Code wiederholt sich! Es muss doch einen besseren Weg geben…

Genau! Den gibt es – und den lernst du in Kapitel 4 kennen, wenn wir über Schleifen sprechen. Schleifen sind ein Weg, Code-Wiederholungen zu vermeiden.

Zusammenfassung

Du hast gerade gelernt:

Wie ein einfaches Rust-Programm aufgebaut ist
Was use, fn main() und #[turtle_main] bedeuten
Wie man die Schildkröte bewegt (forward)
Wie man die Schildkröte dreht (right)
Wie man eine Farbe setzt (set_pen_color)
Wie man das Programm mit dem Run-Button startet
Dass sich Code manchmal wiederholt (das werden wir später eleganter lösen!)

Im nächsten Kapitel schauen wir uns die verschiedenen Bewegungs- und Drehbefehle genauer an.

Bewegung und Drehung

Du hast bereits dein erstes Programm geschrieben und die Schildkröte ein L und ein Quadrat zeichnen lassen. Dabei hast du die Befehle forward() und right() kennengelernt. In diesem Kapitel schauen wir uns alle wichtigen Bewegungsbefehle genauer an und lernen, wie die Schildkröte sich noch bewegen und drehen kann.

Vorwärts und rückwärts gehen

Die Schildkröte kann sich vorwärts und rückwärts bewegen:

Vorwärts gehen

turtle.forward(100.0);

Dieser Befehl bewegt die Schildkröte 100 Schritte vorwärts in die Richtung, in die sie gerade schaut.

Rückwärts gehen

turtle.backward(50.0);

Dieser Befehl bewegt die Schildkröte 50 Schritte rückwärts, ohne dass sie sich umdreht.

Beispiel: Vor und zurück

Hier ist ein Programm, das beides zeigt:

//! Beispiel: Vorwärts und rückwärts bewegen
//!
//! Dieses Programm zeigt, wie man die Schildkröte vorwärts und rückwärts bewegt.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(RED);

    // Gehe vorwärts
    turtle.forward(100.0);

    turtle.set_pen_color(BLUE);

    // Gehe rückwärts
    turtle.backward(50.0);
}

Ergebnis: Eine rote Linie, die zurückläuft

Die Schildkröte geht zuerst 100 Schritte vorwärts, dann 50 Schritte zurück. Die Linie wird rot sein.

Nach links und rechts drehen

Die Schildkröte kann sich drehen, ohne sich zu bewegen:

Nach links drehen

turtle.left(90.0);

Dreht die Schildkröte 90 Grad nach links (gegen den Uhrzeigersinn).

Nach rechts drehen

turtle.right(90.0);

Dreht die Schildkröte 90 Grad nach rechts (im Uhrzeigersinn).

Was sind Grade?

Grade sind ein Maß für Winkel. Ein voller Kreis hat 360 Grad:

90 Grad = ein rechter Winkel (ein Viertel eines Kreises)
180 Grad = ein halber Kreis (die Schildkröte schaut in die entgegengesetzte Richtung)
360 Grad = ein ganzer Kreis (zurück zur Ausgangsrichtung)

Beispiel: Drehen und zeichnen

//! Beispiel: Drehen
//!
//! Dieses Programm zeigt, wie man die Schildkröte dreht.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(GREEN);
    
    // Zeichne eine Linie
    turtle.forward(100.0);
    
    // Drehe nach links
    turtle.left(90.0);
    
    // Zeichne noch eine Linie
    turtle.forward(100.0);
    
    // Drehe nach rechts
    turtle.right(45.0);
    
    // Zeichne eine dritte Linie
    turtle.forward(100.0);
}

Ergebnis: Drei grüne Linien in verschiedenen Winkeln

In diesem Programm:

Die Schildkröte geht vorwärts und zeichnet eine grüne Linie
Sie dreht sich 90 Grad nach links
Sie zeichnet eine weitere Linie
Sie dreht sich 45 Grad nach rechts
Sie zeichnet eine dritte Linie

So entsteht eine interessante Form!

Die Startposition der Schildkröte

Wenn ein Programm startet:

Die Schildkröte ist in der Mitte des Bildschirms
Sie schaut nach rechts (das ist 0 Grad)
Der Stift ist unten (sie zeichnet also)

Übungsaufgaben

Jetzt bist du dran! Hier sind einige Aufgaben, um das Gelernte zu üben.

Aufgabe 1: Geometrische Übung

Zeichne ein Quadrat, eine Box im 45° Winkelund ein gleichseitiges Dreieck mit der Schildkröte. Ein gleichseitiges Dreieck hat drei gleich lange Seiten und drei gleiche Winkel von je 60 Grad.

Hinweis: Du musst die Schildkröte bei jedem Eckpunkt drehen.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein blaues gleichseitiges Dreieck

Aufgabe 2: Haus vom Nikolaus

Kennst du den Spruch “Das ist das Haus vom Nikolaus”? Dabei zeichnet man ein Haus in einem Zug, ohne den Stift abzusetzen. Versuche, diese klassische Zeichenübung nachzuprogrammieren!

Hinweis: Das Haus besteht aus einem Quadrat und einem Dreieck als Dach. Du musst verschiedene Winkel verwenden: 90 Grad für die Ecken des Quadrats und 45 Grad für die Diagonalen. Die Diagonale ist etwas länger als die Seiten (ungefähr 141 statt 100).

So sollte dein Ergebnis aussehen:

Ergebnis: Das Haus vom Nikolaus in Rot

Aufgabe 3: Fünfstern

Zeichne einen fünfzackigen Stern! Dies ist etwas anspruchsvoller, weil du einen besonderen Winkel verwenden musst.

Hinweis: Bei einem fünfzackigen Stern musst du bei jeder Zacke 144 Grad drehen (das ist 720 ÷ 5). Wiederhole die Bewegung forward() und right(144.0) fünf Mal. Da du noch keine Schleifen kennst, musst du den Code fünf Mal schreiben – im nächsten Kapitel lernst du, wie du das eleganter lösen kannst!

So sollte dein Ergebnis aussehen:

Ergebnis: Ein fünfzackiger Stern in Gold

Zusammenfassung

Du hast gelernt:

forward(schritte) - bewegt die Schildkröte vorwärts
backward(schritte) - bewegt die Schildkröte rückwärts
left(grad) - dreht die Schildkröte nach links
right(grad) - dreht die Schildkröte nach rechts
Grade messen Winkel (90° = rechter Winkel, 360° = voller Kreis)

Im nächsten Kapitel lernst du, wie du Kreise und gekrümmte Linien zeichnest – das eröffnet dir völlig neue Möglichkeiten!

Kreise und gekrümmte Linien

Du hast gelernt, wie du gerade Linien und Winkel verwendest, um verschiedene Formen zu zeichnen. Aber nicht alle Formen bestehen aus geraden Linien! In diesem Kapitel lernst du, wie du Kreise und gekrümmte Linien mit der Schildkröte zeichnest – viel einfacher, als viele kleine gerade Linien zu kombinieren!

Was ist eine gekrümmte Linie?

Eine gekrümmte Linie (oder ein Kreisbogen) ist ein Teil eines Kreises. Die Schildkröte zeichnet sanfte Kurven statt nur gerader Linien.

circle_left() – Nach links drehen und zeichnen

Mit circle_left() zeichnest du einen Kreisbogen, bei dem die Schildkröte nach links (gegen den Uhrzeigersinn) dreht:

turtle.circle_left(radius, angle, steps);

radius: Der Abstand vom Mittelpunkt des Kreises zur Schildkröte (in Pixeln)
angle: Der Winkel des Bogens in Grad (360° = ein ganzer Kreis)
steps: Die Anzahl der Liniensegmente (je größer, desto glatter)

Beispiel: Ein Halbkreis nach links

//! Beispiel: Halbkreis nach links
//!
//! Dieses Programm zeichnet einen schwarzen Halbkreis nach links.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(BLACK);
    turtle.circle_left(50.0, 180.0, 36);

    // Dass die Bilder nicht so riesig sind, fügen wir hier noch ein paar Linien hinzu
    turtle.set_pen_color(WHITE);
    turtle.pen_up();
    turtle.backward(200.0);
    turtle.pen_down();
    turtle.forward(1.0);
    turtle.pen_up();
    turtle.forward(400.0);
    turtle.pen_down();
    turtle.forward(1.0);
}

Ergebnis: Ein schwarzer Halbkreis nach links

circle_right() – Nach rechts drehen und zeichnen

Mit circle_right() zeichnest du einen Kreisbogen, bei dem die Schildkröte nach rechts (im Uhrzeigersinn) dreht:

turtle.circle_right(radius, angle, steps);

Die Parameter sind gleich wie bei circle_left(), aber die Kurve dreht sich in die andere Richtung.

Beispiel: Ein Halbkreis nach rechts

//! Beispiel: Halbkreis nach rechts
//!
//! Dieses Programm zeichnet einen blauen Halbkreis nach rechts.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(BLUE);
    turtle.circle_right(50.0, 180.0, 36);
    // Dass die Bilder nicht so riesig sind, fügen wir hier noch ein paar Linien hinzu
    turtle.set_pen_color(WHITE);
    turtle.pen_up();
    turtle.backward(200.0);
    turtle.pen_down();
    turtle.forward(1.0);
    turtle.pen_up();
    turtle.forward(400.0);
    turtle.pen_down();
    turtle.forward(1.0);
}

Ergebnis: Ein blauer Halbkreis nach rechts

Volle Kreise zeichnen

Um einen vollen Kreis zu zeichnen, verwendest du einen Winkel von 360°:

turtle.circle_left(50.0, 360.0, 36);

Das zeichnet einen perfekten Kreis mit einem Radius von 50 Pixeln!

Kombinieren von Kurven

Du kannst mehrere circle_left() und circle_right() Befehle hintereinander verwenden, um komplexere Formen zu erstellen. Zum Beispiel:

turtle.circle_left(50.0, 180.0, 36);   // Halbkreis nach links
turtle.circle_right(50.0, 180.0, 36);  // Halbkreis nach rechts

Das zeichnet eine S-förmige Kurve!

Übungsaufgaben

Jetzt bist du dran! Hier sind einige Aufgaben, um das Gelernte zu üben.

Aufgabe 1: Ein Herz

Zeichne ein Herz! Ein Herz besteht aus zwei Halbkreisen oben und einer Spitze unten.

Hinweis: Beginne unten bei der Spitze.Du kannst das Herz mit circle_right() für die beiden oberen Rundungen zeichnen.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein rotes Herz

Aufgabe 2: Ein Stern mit abgerundeten Spitzen

Zeichne einen Stern wie in Kapitel 4, aber mit abgerundeten Spitzen statt scharfen Ecken!

Hinweis: Statt forward() und right() direkt zu verwenden, nutze circle_right() für die Spitzen des Sterns. Das gibt ihnen eine schöne, gerundete Form. Du brauchst 5 Schleifen für die 5 Spitzen des Sterns.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein Stern mit abgerundeten Spitzen

Aufgabe 3: Yin und Yang

Zeichne das klassische Yin-Yang Symbol mit zwei ineinanderliegenden Kurven!

Hinweis: Das Yin-Yang Symbol besteht aus einer großen Kurve, die den Kreis halbiert, und einer kleineren Kurve, die die andere Hälfte füllt. Verwende circle_right() und circle_left() in Kombination. Du kannst auch verschiedene Radien und Füllfarben verwenden.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein schwarzes und weißes Yin-Yang Symbol

Aufgabe 4: Eine Blume

Zeichne eine Blume mit Blütenblättern! Jedes Blütenblatt ist eine gekrümmte Form.

Hinweis: Eine Blume besteht aus mehreren Blütenblättern, die in einem Kreis angeordnet sind. Du kannst jedes Blütenblatt mit circle_left() und circle_right() zeichnen und dann die Schildkröte drehen, um das nächste Blütenblatt zu zeichnen. Eine Schleife hilft dir dabei!

So sollte dein Ergebnis aussehen:

Ergebnis: Eine bunte Blume mit mehreren Blütenblättern

Zusammenfassung

Du hast gelernt:

circle_left(radius, angle, steps) - Zeichnet einen Kreisbogen nach links
circle_right(radius, angle, steps) - Zeichnet einen Kreisbogen nach rechts
Mit angle = 360.0 zeichnest du einen vollen Kreis
Mit Kurven kannst du viel interessantere und realistischere Formen zeichnen

Im nächsten Kapitel lernst du, wie du mit Farben arbeitest und den Stift heben und senken kannst.

Farben und Stift

Du hast gelernt, wie du gerade Linien oder gekrümmte Kurven zeichnest. Jetzt machen wir unsere Zeichnungen bunter! Viele der Beispiele haben schon farben verwendet. In diesem Kapitel lernst du, wie du die Farbe änderst und den Stift hebst und senkst und wie du Flächen füllst.

Die Stiftfarbe ändern

Du kannst die Farbe des Stifts jederzeit ändern:

turtle.set_pen_color(RED);    // Rot
turtle.set_pen_color(BLUE);   // Blau
turtle.set_pen_color(GREEN);  // Grün
turtle.set_pen_color(YELLOW); // Gelb

Verfügbare Farben

Die Turtle-Bibliothek bietet viele vordefinierte Farben:

RED (Rot)
BLUE (Blau)
GREEN (Grün)
YELLOW (Gelb)
ORANGE (Orange)
PURPLE (Lila)
PINK (Rosa)
BLACK (Schwarz)
WHITE (Weiß)
GOLD (Gold)

Wenn du mehr Farben möchtest, kannst du mit use macroquad::color::colors::*; noch mehr Farben verwenden, z.B. DARKGREEN, CYAN, MAGENTA und viele mehr! Eine Liste der Farben bekommt man, wenn man nach dem einbinden von macroquad::color::colors die Autovervollständigung des Editors benutzt, also colors:: eingibt und dann die Vorschläge anschaut.

Beispiel: Bunte Linien

//! Beispiel: Farben verwenden
//!
//! Dieses Programm zeigt verschiedene Farben.

use macroquad::color::colors;
use turtle_lib::*;

#[turtle_main]
fn main() {
    // Rote Linie
    turtle.set_pen_color(RED);
    turtle.forward(100.0);

    // Drehe und zeichne eine blaue Linie
    turtle.left(90.0);
    turtle.set_pen_color(BLUE);
    turtle.forward(100.0);

    // Drehe und zeichne eine grüne Linie
    turtle.left(90.0);
    turtle.set_pen_color(GREEN);
    turtle.forward(100.0);

    // Drehe und zeichne eine gelbe Linie
    turtle.left(90.0);
    turtle.set_pen_color(YELLOW);
    turtle.forward(100.0);

    // Drehe und zeichne eine Violette Linie
    turtle.left(135.0);
    turtle.set_pen_color(colors::VIOLET);
    turtle.forward(141.0);
}

Ergebnis: Ein buntes Quadrat mit verschiedenen Farben

Dieses Programm zeichnet ein buntes Quadrat, bei dem jede Seite eine andere Farbe hat!

Den Stift heben und senken

Manchmal möchtest du die Schildkröte bewegen, ohne eine Linie zu zeichnen. Dafür kannst du den Stift heben:

Stift heben

turtle.pen_up();

Nach diesem Befehl zeichnet die Schildkröte keine Linie mehr, wenn sie sich bewegt.

Stift senken

turtle.pen_down();

Nach diesem Befehl zeichnet die Schildkröte wieder Linien.

Beispiel: Unterbrochene Linie

//! Beispiel: Stift heben und senken
//!
//! Dieses Programm zeigt, wie man den Stift hebt und senkt.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(RED);
    
    // Zeichne eine Linie
    turtle.forward(50.0);
    
    // Hebe den Stift (keine Linie mehr)
    turtle.pen_up();
    turtle.forward(50.0);
    
    // Senke den Stift wieder (zeichne wieder)
    turtle.pen_down();
    turtle.forward(50.0);
}

Ergebnis: Zwei getrennte blaue Linien

Dieses Programm zeichnet eine Linie, hebt dann den Stift, bewegt sich ohne zu zeichnen, und zeichnet dann wieder eine Linie. Es entsteht eine unterbrochene Linie!

Flächen ausfüllen

Du kannst auch Formen mit Farbe ausfüllen:

//! Beispiel: Fläche ausfüllen
//!
//! Dieses Programm zeichnet ein ausgefülltes Dreieck.

use turtle_lib::*;

#[turtle_main]
fn main() {
    // Setze die Füllfarbe
    turtle.set_fill_color(BLUE);
    turtle.set_pen_color(BLACK);

    // Beginne mit dem Füllen
    turtle.begin_fill();

    // Zeichne ein Dreieck
    turtle.forward(100.0);
    turtle.left(120.0);
    turtle.forward(100.0);
    turtle.left(120.0);
    turtle.forward(100.0);
    turtle.left(120.0);

    // Beende das Füllen
    turtle.end_fill();
}

Ergebnis: Ein ausgefülltes blaues Dreieck mit grünem Rand

Wie funktioniert das Füllen?

set_fill_color(BLUE) - Setzt die Füllfarbe auf Blau
begin_fill() - Beginnt mit dem Füllen (merkt sich den Startpunkt)
Zeichne die Form (hier ein Dreieck)
end_fill() - Beendet das Füllen und füllt die Form aus

Die Form wird automatisch zwischen dem Start- und Endpunkt geschlossen und ausgefüllt.

Die Stiftdicke ändern

Du kannst auch die Dicke des Stifts ändern:

turtle.set_pen_width(5.0);  // Dicker Stift
turtle.set_pen_width(1.0);  // Dünner Stift

Je größer die Zahl, desto dicker die Linie!

Übungsaufgaben

Jetzt bist du dran! Hier sind einige Aufgaben, um das Gelernte zu üben.

Aufgabe 1: Ein ausgefüllter Stern

Zeichne einen fünfzackigen Stern und fülle ihn mit einer Farbe aus!

Hinweis: Verwende begin_fill() vor dem Zeichnen des Sterns und end_fill() danach. Du kannst die Füllfarbe mit set_fill_color() setzen und die Randfarbe mit set_pen_color() wählen. Für den Stern brauchst du eine Schleife mit 5 Wiederholungen und einem Drehwinkel von 144 Grad.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein ausgefüllter goldener Stern

Aufgabe 2: Ein Käse

Zeichne ein gelbes Käsestück! Ein Käsestück ist ein Viereck mit drei runden Löchern darin.

Hinweis: Zeichne zuerst ein ausgefülltes gelbes Viereck. Dann hebe den Stift (pen_up()), bewege die Schildkröte zu verschiedenen Positionen mit goto(x, y), senke den Stift wieder (pen_down()) und zeichne drei kleine ausgefüllte weiße Kreise (du kannst einen Kreis zeichnen, indem du ein Vieleck mit vielen Seiten und kleinen Winkeln zeichnest, z.B. 36 Seiten mit je 10 Grad Drehung).

So sollte dein Ergebnis aussehen:

Ergebnis: Ein gelbes Käsestück mit drei weißen Löchern

Aufgabe 3: Drei ineinanderliegende Quadrate

So sollte dein Ergebnis aussehen:

Ergebnis: Drei bunte Quadrate, die ineinander liegen

Zeichne drei Quadrate, die ineinander liegen, aber sich nicht berühren!

Hinweis: Zeichne zuerst ein kleines Quadrat in der Mitte. Dann hebe den Stift (pen_up()), bewege die Schildkröte etwas nach links und unten, senke den Stift (pen_down()) und zeichne ein größeres Quadrat. Wiederhole das für ein drittes, noch größeres Quadrat. Du kannst auch verschiedene Farben für jedes Quadrat verwenden!

Zusammenfassung

Du hast gelernt:

set_pen_color(farbe) - Ändert die Stiftfarbe
pen_up() - Hebt den Stift (zeichnet nicht mehr)
pen_down() - Senkt den Stift (zeichnet wieder)
set_fill_color(farbe) - Setzt die Füllfarbe
begin_fill() - Beginnt mit dem Füllen einer Form
end_fill() - Beendet das Füllen und füllt die Form aus
set_pen_width(dicke) - Ändert die Stiftdicke

Im nächsten Kapitel lernst du, wie du Schleifen verwendest, um deine Zeichnungen noch effizienter zu machen!

Wiederholungen (Schleifen)

Du kennst jetzt gerade Linien und auch gekrümmte Linien mit Kreisen. Egal ob gerade oder gekrümmt – wenn du die gleiche Bewegung mehrmals hintereinander brauchst, möchtest du das nicht jedes Mal von Hand aufschreiben. In diesem Kapitel lernst du Schleifen – damit kannst du Befehle automatisch wiederholen!

turtle.forward(100.0);
turtle.right(90.0);

turtle.forward(100.0);
turtle.right(90.0);

turtle.forward(100.0);
turtle.right(90.0);

turtle.forward(100.0);
turtle.right(90.0);

Das war ziemlich mühsam! Stell dir vor, du möchtest 100 mal den gleichen Befehl ausführen. Es wäre sehr mühsam, diesen Befehl 100 mal zu schreiben! Hier kommen Schleifen ins Spiel.

Was ist eine Schleife?

Eine Schleife ist ein Programmierkonstrukt, das Befehle mehrmals wiederholt. Du sagst dem Computer: “Führe diese Befehle X-mal aus.”

Die for-Schleife

Die häufigste Art von Schleife ist die for-Schleife. Hier ist die Grundstruktur:

for _ in 0..anzahl {
    // Befehle, die wiederholt werden
}

for bedeutet “für jede Wiederholung”
0..anzahl gibt an, wie oft wiederholt wird (von 0 bis anzahl-1)
Der Unterstrich _ bedeutet, dass wir die Zählvariable nicht brauchen
Die Befehle innerhalb der geschweiften Klammern { } werden wiederholt

Aufgabe 1: Ein Quadrat mit Schleife

Erinnere dich an unser Quadrat von vorhin. Versuche jetzt, ein Quadrat mit einer Schleife zu zeichnen. Das wird viel kürzer und übersichtlicher als den Code viermal zu schreiben!

Hinweis: Ein Quadrat hat 4 Seiten. Die Formel 360 ÷ 4 = 90 Grad zeigt dir den Drehwinkel.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein rotes Quadrat mit Schleife gezeichnet

Lösungsblock

Zeige die Lösung

//! Beispiel: Ein Quadrat mit Schleife zeichnen
//!
//! Dieses Programm zeichnet ein Quadrat mit einer Schleife.

use turtle_lib::*;

#[turtle_main]
fn main() {
    // Setze die Stiftfarbe auf Blau
    turtle.set_pen_color(BLUE);
    
    // Zeichne ein Quadrat mit 4 Seiten
    for _ in 0..4 {
        turtle.forward(100.0);  // Gehe 100 Schritte vorwärts
        turtle.right(90.0);     // Drehe 90 Grad nach rechts
    }
}

Statt 8 Zeilen Code haben wir jetzt nur noch 3 Zeilen in der Schleife. Das macht genau das Gleiche wie der lange Code vorher, ist aber viel einfacher zu lesen und zu verstehen!

Aufgabe 2: Ein Achteck

Ein Achteck hat 8 gleich lange Seiten. Versuche, es mit einer Schleife zu zeichnen.

Hinweis: Verwende die Formel 360 ÷ 8 = 45 Grad für den Drehwinkel. Du brauchst eine Schleife mit 8 Wiederholungen.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein gelbes Achteck

Die Formel für regelmäßige Vielecke

Für ein Vieleck mit n Seiten ist der Drehwinkel:

360 ÷ n

Beispiele:

Dreieck (3 Seiten): 360 ÷ 3 = 120 Grad
Quadrat (4 Seiten): 360 ÷ 4 = 90 Grad
Fünfeck (5 Seiten): 360 ÷ 5 = 72 Grad
Sechseck (6 Seiten): 360 ÷ 6 = 60 Grad
Achteck (8 Seiten): 360 ÷ 8 = 45 Grad

Aufgabe 3: Ein Stern

Wollen wir etwas Komplexeres zeichnen? Versuche, einen fünfzackigen Stern zu zeichnen!

Hinweis: Ein fünfzackiger Stern braucht einen anderen Winkel als ein regelmäßiges Fünfeck. Hier verwendest du 144 Grad (das ist 720 ÷ 5). Du brauchst eine Schleife mit 5 Wiederholungen.

So sollte dein Ergebnis aussehen:

Ergebnis: Ein fünfzackiger Stern in Orange

Warum sind Schleifen nützlich?

Schleifen sind sehr nützlich, weil:

Weniger Code: Statt 8 mal den gleichen Befehl zu schreiben, schreibst du ihn nur einmal
Weniger Fehler: Du kannst dich nicht vertippen, wenn du nur einmal schreibst
Leichter zu ändern: Willst du ein Zehneck statt eines Achtecks? Ändere einfach die 8 zu 10!

Weitere Aufgaben zum Üben

Versuche, diese Formen zu zeichnen:

Ein Dreieck (3 Seiten, 120 Grad)
Ein Sechseck (6 Seiten, 60 Grad)
Ein Zwölfeck (12 Seiten, 30 Grad)

Zusammenfassung

Du hast gelernt:

Was eine Schleife ist (ein Befehl, der sich wiederholt)
Wie man eine for-Schleife schreibt
Die Formel für regelmäßige Vielecke: 360 ÷ anzahl_seiten
Dass Schleifen den Code kürzer und einfacher machen

Im nächsten Kapitel lernst du, wie du Werte speichern und wiederverwenden kannst – mit Variablen!

Variablen

Du kannst jetzt bunte Zeichnungen erstellen und hast gelernt, wie du den Stift hebst und senkst. Aber was, wenn du bestimmte Werte – wie die Größe eines Quadrats oder die Anzahl der Seiten – mehrmals verwenden möchtest? Hier kommen Variablen ins Spiel. Variablen sind wie Schubladen, in denen du Werte aufbewahren kannst. Sie machen deine Programme flexibler und leichter zu verstehen.

Was ist eine Variable?

Eine Variable ist ein Name, der einen Wert speichert. Stell dir vor, du hast eine Schublade mit dem Etikett “Seitenlänge”. In dieser Schublade liegt eine Zahl, zum Beispiel 80. Immer wenn du diese Zahl brauchst, schaust du in die Schublade “Seitenlänge”.

In Rust sieht das so aus:

let seitenlaenge = 80.0;

let bedeutet “lass” oder “erstelle” (eine neue Variable)
seitenlaenge ist der Name der Variable
= bedeutet “bekommt den Wert”
80.0 ist der Wert, den wir speichern

Warum Variablen verwenden?

Variablen haben mehrere Vorteile:

Lesbarkeit: Der Code ist leichter zu verstehen
Wiederverwendung: Du kannst den Wert mehrmals verwenden
Änderbarkeit: Du musst nur an einer Stelle ändern

Beispiel: Quadrat mit Variable

//! Beispiel: Variablen verwenden
//!
//! Dieses Programm verwendet Variablen für die Größe des Quadrats.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(GREEN);
    
    // Eine Variable für die Seitenlänge
    let seitenlaenge = 80.0;
    
    // Zeichne ein Quadrat mit dieser Seitenlänge
    for _ in 0..4 {
        turtle.forward(seitenlaenge);
        turtle.right(90.0);
    }
}

Ergebnis: Ein grünes Quadrat mit der Seitenlänge aus der Variable

Hier verwenden wir eine Variable seitenlaenge für die Größe des Quadrats. Wenn wir die Größe ändern wollen, müssen wir nur die Zeile let seitenlaenge = 80.0; ändern, statt alle vier forward-Befehle!

Mehrere Variablen

Du kannst so viele Variablen verwenden, wie du möchtest:

//! Beispiel: Mehrere Variablen
//!
//! Dieses Programm verwendet mehrere Variablen.

use turtle_lib::*;

#[turtle_main]
fn main() {
    // Variablen für verschiedene Werte
    let seitenlaenge = 60.0;
    let anzahl_seiten = 6;
    let winkel = 60.0;
    
    turtle.set_pen_color(ORANGE);
    
    // Zeichne ein Sechseck
    for _ in 0..anzahl_seiten {
        turtle.forward(seitenlaenge);
        turtle.right(winkel);
    }
}

Ergebnis: Ein rosa Achteck mit Variablen für Seiten und Winkel

Hier haben wir drei Variablen:

seitenlaenge - für die Länge jeder Seite
anzahl_seiten - für die Anzahl der Seiten
winkel - für den Drehwinkel

Das macht den Code sehr übersichtlich!

Variablen in Schleifen verwenden

Du kannst auch Variablen in Schleifen verwenden:

for _ in 0..anzahl_seiten {
    turtle.forward(seitenlaenge);
    turtle.right(winkel);
}

Hier verwenden wir anzahl_seiten als Anzahl der Wiederholungen!

Variablen ändern

Manchmal möchtest du den Wert einer Variable ändern. Dafür brauchst du das Wort mut (von “mutable” = veränderbar):

let mut laenge = 5.0;
laenge = laenge + 3.0;  // Jetzt ist laenge 8.0

Beispiel: Spirale mit sich ändernder Variable

//! Beispiel: Spirale
//!
//! Dieses Programm zeichnet eine Spirale.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(PURPLE);
    
    let mut laenge = 5.0;
    
    // Zeichne eine Spirale
    for _ in 0..50 {
        turtle.forward(laenge);
        turtle.right(90.0);
        laenge = laenge + 3.0;  // Erhöhe die Länge bei jedem Schritt
    }
}

Ergebnis: Eine lila Spirale mit zunehmender Linienlänge

Hier beginnt laenge bei 5.0 und wird in jedem Schritt um 3.0 erhöht. So entsteht eine Spirale, bei der die Linien immer länger werden!

Rechenoperationen mit Variablen

Du kannst mit Variablen rechnen:

let a = 10.0;
let b = 5.0;
let summe = a + b;        // 15.0 (Addition)
let differenz = a - b;    // 5.0 (Subtraktion)
let produkt = a * b;      // 50.0 (Multiplikation)
let quotient = a / b;     // 2.0 (Division)

Zahlentypen

In Rust gibt es verschiedene Arten von Zahlen:

Ganze Zahlen (ohne Komma): let anzahl = 5;
Kommazahlen (mit Punkt): let laenge = 10.0;

Für die Turtle-Befehle brauchst du meist Kommazahlen (mit .0 am Ende).

Gute Namen für Variablen

Wähle Namen, die beschreiben, was in der Variable gespeichert ist:

Gut:

seitenlaenge
anzahl_wiederholungen
drehwinkel

Nicht so gut:

x
zahl1
dings

Gute Namen machen deinen Code viel leichter verständlich!

Zusammenfassung

Du hast gelernt:

let name = wert; - Erstellt eine Variable
let mut name = wert; - Erstellt eine veränderbare Variable
Variablen machen Code lesbarer und flexibler
Du kannst mit Variablen rechnen
Gute Variablennamen sind wichtig für verständlichen Code

Im nächsten Kapitel lernst du Funktionen kennen – eine Möglichkeit, Code zu organisieren und wiederzuverwenden!

Funktionen

Mit Variablen kannst du Werte speichern und wiederverwenden – das hast du im letzten Kapitel gelernt. Aber was, wenn du nicht nur Werte, sondern ganze Code-Abschnitte wiederverwenden möchtest? Hier kommen Funktionen ins Spiel. Funktionen sind wie kleine Unterprogramme, die eine bestimmte Aufgabe erledigen. Sie helfen dir, deinen Code zu organisieren und wiederzuverwenden.

Was ist eine Funktion?

Eine Funktion ist ein benannter Block von Code, den du immer wieder aufrufen kannst. Stell dir vor, du hast ein Rezept für Pfannkuchen. Anstatt jedes Mal die ganze Anleitung aufzuschreiben, sagst du einfach “Mache Pfannkuchen” – und alle wissen, was zu tun ist.

Die main-Funktion

Du kennst bereits eine Funktion – die main-Funktion! Das ist die Funktion, in der dein Programm startet:

fn main() {
    // Dein Code hier
}

Eine eigene Funktion erstellen

So erstellst du eine eigene Funktion:

fn zeichne_quadrat(turtle: &mut TurtlePlan, groesse: f32) {
    for _ in 0..4 {
        turtle.forward(groesse);
        turtle.right(90.0);
    }
}

Was bedeutet das?

fn bedeutet “function” (Funktion)
zeichne_quadrat ist der Name der Funktion
(turtle: &mut TurtlePlan, groesse: f32) sind die Parameter (Werte, die die Funktion braucht)
Der Code zwischen { } wird ausgeführt, wenn die Funktion aufgerufen wird

Parameter

Parameter sind Werte, die du einer Funktion übergibst. In unserem Beispiel:

turtle: &mut TurtlePlan - Die Schildkröte, die zeichnen soll
groesse: f32 - Die Größe des Quadrats

So kann die gleiche Funktion Quadrate in verschiedenen Größen zeichnen!

Eine Funktion aufrufen

Um eine Funktion zu verwenden, rufst du sie auf:

zeichne_quadrat(&mut turtle, 50.0);

Das bedeutet: “Führe die Funktion zeichne_quadrat aus und übergib ihr die Schildkröte und die Größe 50.0.”

Vollständiges Beispiel

//! Beispiel: Funktionen verwenden
//!
//! Dieses Programm zeigt, wie man eigene Funktionen erstellt.

use turtle_lib::*;

// Eine Funktion, die ein Quadrat zeichnet
fn zeichne_quadrat(turtle: &mut TurtlePlan, groesse: f32) {
    for _ in 0..4 {
        turtle.forward(groesse);
        turtle.right(90.0);
    }
}

#[turtle_main]
fn main() {
    turtle.set_pen_color(BLUE);
    
    // Zeichne ein kleines Quadrat
    zeichne_quadrat(turtle, 50.0);
    
    // Bewege die Schildkröte
    turtle.pen_up();
    turtle.forward(120.0);
    turtle.pen_down();
    
    // Zeichne ein größeres Quadrat
    turtle.set_pen_color(RED);
    zeichne_quadrat(turtle, 80.0);
}

Ergebnis: Zwei Quadrate in verschiedenen Größen und Farben

Dieses Programm:

Definiert eine Funktion zeichne_quadrat
Zeichnet ein kleines Quadrat (50.0)
Bewegt die Schildkröte
Zeichnet ein größeres Quadrat (80.0) in einer anderen Farbe

Die Funktion können wir so oft aufrufen, wie wir wollen – mit verschiedenen Größen!

Mehrere Funktionen

Du kannst so viele Funktionen erstellen, wie du möchtest:

//! Beispiel: Mehrere Formen
//!
//! Dieses Programm zeichnet mehrere verschiedene Formen.

use turtle_lib::*;

fn zeichne_dreieck(turtle: &mut TurtlePlan, groesse: f32) {
    for _ in 0..3 {
        turtle.forward(groesse);
        turtle.left(120.0);
    }
}

fn zeichne_quadrat(turtle: &mut TurtlePlan, groesse: f32) {
    for _ in 0..4 {
        turtle.forward(groesse);
        turtle.right(90.0);
    }
}

#[turtle_main]
fn main() {
    // Zeichne ein Dreieck
    turtle.set_pen_color(RED);
    zeichne_dreieck(turtle, 80.0);
    
    // Bewege zur nächsten Position
    turtle.pen_up();
    turtle.forward(150.0);
    turtle.pen_down();
    
    // Zeichne ein Quadrat
    turtle.set_pen_color(BLUE);
    zeichne_quadrat(turtle, 70.0);
}

Ergebnis: Ein gelbes Dreieck und ein rotes Quadrat nebeneinander

Hier haben wir zwei Funktionen:

zeichne_dreieck - zeichnet ein Dreieck
zeichne_quadrat - zeichnet ein Quadrat

Jede Funktion macht genau eine Sache – das macht den Code übersichtlich!

Warum Funktionen verwenden?

Funktionen haben viele Vorteile:

Wiederverwendung: Schreibe den Code einmal, verwende ihn oft
Organisation: Teile komplexe Programme in kleine, verständliche Teile
Lesbarkeit: zeichne_stern() ist leichter zu verstehen als 20 Zeilen Code
Fehlersuche: Wenn etwas nicht funktioniert, weißt du genau, wo du suchen musst

Funktionen ohne Parameter

Funktionen müssen nicht unbedingt Parameter haben:

fn zeichne_stern(turtle: &mut TurtlePlan) {
    for _ in 0..5 {
        turtle.forward(100.0);
        turtle.right(144.0);
    }
}

Diese Funktion zeichnet immer einen Stern mit der gleichen Größe.

Das DRY-Prinzip

Programmierer folgen oft dem DRY-Prinzip: “Don’t Repeat Yourself” (Wiederhole dich nicht).

Schlecht (sich wiederholend):

// Quadrat 1
for _ in 0..4 {
    turtle.forward(50.0);
    turtle.right(90.0);
}
// ... Position ändern ...
// Quadrat 2
for _ in 0..4 {
    turtle.forward(80.0);
    turtle.right(90.0);
}

Gut (mit Funktion):

zeichne_quadrat(&mut turtle, 50.0);
// ... Position ändern ...
zeichne_quadrat(&mut turtle, 80.0);

Die Version mit Funktion ist kürzer, klarer und leichter zu ändern!

Übungsaufgaben

Jetzt bist du dran! Hier sind Aufgaben zum Üben von Funktionen. Denke daran: Mit Funktionen kannst du denselben Code immer wieder aufrufen – und mit Parametern kannst du ihn flexibel gestalten!

Aufgabe 1: Dreieck-Funktion

Erstelle eine Funktion zeichne_dreieck(), die ein gleichseitiges Dreieck zeichnet. Die Funktion soll einen Parameter groesse haben, damit du Dreiecke verschiedener Größen zeichnen kannst.

Aufgabe 2: Viereck und Fünfeck

Schreibe zwei Funktionen:

zeichne_viereck(turtle: &mut TurtlePlan, groesse: f32) für ein Quadrat
zeichne_fuenfeck(turtle: &mut TurtlePlan, groesse: f32) für ein regelmäßiges Fünfeck

Aufgabe 3: Fünfstern-Funktion

Erstelle eine Funktion zeichne_fuenfstern(), die einen fünfzackigen Stern zeichnet. Der Stern soll einen Parameter groesse haben.

Aufgabe 4: Herz-Funktion

Schreibe eine Funktion zeichne_herz(), die ein Herz zeichnet. Das ist anspruchsvoll – überlege, wie du Kurven mit geraden Linien und Drehungen näherungsweise zeichnen kannst!

Aufgabe 5: Blume-Funktion

Erstelle eine Funktion zeichne_blume(turtle: &mut TurtlePlan, blaetter: i32), die eine Blume mit mehreren Blütenblättern zeichnet. Die Funktion soll bestimmen können, wie viele Blütenblätter die Blume hat.

Tipp: Zeichne ein Blütenblatt (Kreis), drehe die Schildkröte dann um einen Winkel und wiederhole das. Bei blaetter Blättern drehst du jeweils um 360 / blaetter Grad.

Aufgabe 6: Haus mit Funktionen

Schreibe eine Funktion zeichne_haus(turtle: &mut TurtlePlan, breite: f32), die ein komplettes Haus zeichnet (ein Quadrat mit einem dreieckigen Dach). Die Größe soll über den Parameter breite bestimmt werden.

Rufe die Funktion mehrmals auf, um ein ganzes Dorf mit unterschiedlich großen Häusern zu zeichnen! Bewege die Schildkröte zwischen den Häusern mit forward() und backward(), damit die Häuser nebeneinander stehen.

Zusammenfassung

Du hast gelernt:

fn name() { } - Erstellt eine neue Funktion
Parameter ermöglichen es, Werte an Funktionen zu übergeben
Funktionen machen Code wiederverwendbar und übersichtlich
Das DRY-Prinzip: “Don’t Repeat Yourself”
Jede Funktion sollte eine klare Aufgabe haben

Im nächsten Kapitel siehst du weitere kreative Beispiele, die alles zusammenbringen, was du gelernt hast!

Weitere Beispiele

Du hast in den letzten Kapiteln viel gelernt: Bewegung, Schleifen, Farben, Variablen und Funktionen. Jetzt ist es Zeit, alles zusammenzubringen! In diesem Kapitel schauen wir uns einige kreative Beispiele an, die zeigen, was du mit der Turtle-Grafik alles machen kannst.

Die Spirale

Eine Spirale entsteht, wenn die Schildkröte sich bewegt und dabei die Schrittlänge immer weiter erhöht:

//! Beispiel: Spirale
//!
//! Dieses Programm zeichnet eine Spirale.

use turtle_lib::*;

#[turtle_main]
fn main() {
    turtle.set_pen_color(PURPLE);
    
    let mut laenge = 5.0;
    
    // Zeichne eine Spirale
    for _ in 0..50 {
        turtle.forward(laenge);
        turtle.right(90.0);
        laenge = laenge + 3.0;  // Erhöhe die Länge bei jedem Schritt
    }
}

Ergebnis: Eine lila Spirale

Was passiert hier?

Wir starten mit einer Länge von 5.0
In jeder Runde zeichnen wir eine Linie und drehen uns
Die Länge wird um 3.0 erhöht
Nach 50 Wiederholungen entsteht eine schöne Spirale

Ideen zum Experimentieren

Jetzt bist du dran! Hier sind einige Ideen, was du ausprobieren kannst:

1. Muster mit verschiedenen Farben

Versuche, ein Programm zu schreiben, das mehrere Quadrate in verschiedenen Farben zeichnet, die sich überlappen.

Tipp: Verwende pen_up() und pen_down(), um die Schildkröte zwischen den Quadraten zu bewegen.

2. Ein Haus zeichnen

Zeichne ein einfaches Haus:

Ein Quadrat für das Gebäude
Ein Dreieck für das Dach
Ein kleines Rechteck für die Tür
Zwei kleine Quadrate für die Fenster

Tipp: Erstelle Funktionen für zeichne_rechteck() und zeichne_dreieck().

3. Eine Blume

Zeichne eine Blume mit mehreren Blütenblättern:

Jedes Blütenblatt ist ein ausgefüllter Kreis oder eine Ellipse
Drehe die Schildkröte nach jedem Blütenblatt
Verwende verschiedene Farben

4. Ein Regenbogen

Zeichne konzentrische Halbkreise in verschiedenen Farben:

Rot (außen)
Orange
Gelb
Grün
Blau
Lila (innen)

Tipp: Du kannst circle_left() oder circle_right() für Kreisbögen verwenden.

5. Dein Name

Versuche, die Buchstaben deines Namens mit der Schildkröte zu zeichnen!

Tipps für kreative Zeichnungen

Plane vorher: Überlege dir, welche Formen du brauchst
Funktionen: Erstelle Funktionen für wiederholte Formen
Farben: Experimentiere mit verschiedenen Farben
Füllung: Verwende begin_fill() und end_fill() für ausgefüllte Formen
Position: Nutze pen_up() und pen_down(), um die Schildkröte zu bewegen

Was du bis jetzt gelernt hast

Herzlichen Glückwunsch! Du hast die Grundlagen des Programmierens gelernt:

Konzepte

Sequenz: Befehle werden nacheinander ausgeführt
Wiederholung: Schleifen wiederholen Befehle
Variablen: Werte speichern und wiederverwenden
Funktionen: Code organisieren und wiederverwenden

Turtle-Befehle

Bewegung: forward(), backward()
Drehung: left(), right()
Farben: set_pen_color(), set_fill_color()
Stift: pen_up(), pen_down()
Füllung: begin_fill(), end_fill()
Dicke: set_pen_width()

Rust-Grundlagen

let für Variablen
for für Schleifen
fn für Funktionen
Kommentare mit //

Wie geht es weiter?

Du hast jetzt eine solide Grundlage für das Programmieren! Hier sind einige Ideen, wie du weitermachen kannst:

Mehr üben: Je mehr du programmierst, desto besser wirst du
Eigene Projekte: Überlege dir eigene Zeichnungen und setze sie um
Rust lernen: Die Turtle-Grafik ist nur der Anfang – Rust kann noch viel mehr!
Teilen: Zeige deine Zeichnungen anderen und lass dich inspirieren

Wichtige Tipps für Anfänger

Fehler sind normal: Jeder Programmierer macht Fehler – auch erfahrene!
Ausprobieren: Experimentiere mit dem Code und schau, was passiert
Kleine Schritte: Ändere immer nur eine Sache und teste dann
Fragen stellen: Wenn du nicht weiterkommst, frage jemanden oder suche online

Abschluss

Programmieren ist wie eine neue Sprache lernen – am Anfang ist es ungewohnt, aber mit der Zeit wird es immer leichter. Die Schildkröten-Grafik ist ein großartiger Einstieg, weil du sofort siehst, was dein Code bewirkt.

Viel Erfolg und viel Spaß beim Programmieren! 🎉🐢

Hinweis: Diese Anleitung basiert auf der Turtle-Bibliothek von turtlers. Weitere Informationen findest du in der offiziellen Dokumentation.

Keyboard shortcuts

Rustanleitung - Programmieren lernen mit Rust