Armee der Klone in Scratch: So programmieren Sie es, damit Klone Ihnen folgen!

Haben Sie sich jemals vorgestellt, wie es wäre, in Ihrem eigenen Spiel eine treue Armee von Klonen zu haben, die Ihnen auf Schritt und Tritt folgt? In Scratch, der beliebten visuellen Programmiersprache, ist das nicht nur möglich, sondern auch überraschend einfach zu realisieren! Ob für ein Strategie-Spiel, ein actiongeladenes Abenteuer oder einfach nur, um coole visuelle Effekte zu erzeugen – die Fähigkeit, Klone zu steuern, die Ihrem Hauptcharakter folgen, eröffnet eine Welt voller kreativer Möglichkeiten. In diesem umfassenden Guide tauchen wir tief in die Welt der Scratch-Klone ein und zeigen Ihnen verschiedene Techniken, wie Sie Ihre eigene digitale Gefolgschaft erschaffen können, die Ihnen loyal folgt.

## Was sind Klone in Scratch und warum sind sie so mächtig?

Bevor wir uns dem „Wie” widmen, lassen Sie uns kurz klären, was Klone in Scratch überhaupt sind. Ein Klon ist im Wesentlichen eine exakte Kopie eines vorhandenen Sprites (oder des Sprites, von dem er geklont wurde). Stellen Sie sich vor, Sie haben einen Sprite namens „Krieger”. Wenn Sie ihn klonen, erhalten Sie einen weiteren „Krieger”, der genauso aussieht und sich initial genauso verhält. Der Clou: Jeder Klon kann *unabhängig* von seinem Original-Sprite und anderen Klonen agieren. Sie können individuelle Skripte ausführen oder auf Nachrichten reagieren, sobald sie „entstehen”.

Diese Fähigkeit zur unabhängigen Bewegung und Interaktion macht Klone unglaublich mächtig für eine Vielzahl von Anwendungen:
* Gegnerwellen: Erzeugen Sie unzählige Feinde aus einem einzigen Sprite.
* Partikelsysteme: Realisieren Sie Rauch, Funken, Regentropfen oder Explosionen.
* Sammelobjekte: Erstellen Sie eine Vielzahl von Münzen, Früchten oder Power-Ups.
* Animationen: Komplexe Animationen mit vielen sich bewegenden Teilen.
* Und natürlich: Armeen oder Gefolgschaften, die Ihrem Hauptcharakter folgen!

Das Herzstück der Klonerstellung sind zwei entscheidende Blöcke:
* Erzeuge Klon von [myself/Sprite Name]: Dieser Block erstellt eine Kopie des ausgewählten Sprites.
* Wenn ich als Klon entstehe: Alle Skripte, die unter diesem Hutblock platziert werden, werden nur von den Klonen ausgeführt, nicht vom Original-Sprite.

## Warum Klone folgen lassen? Anwendungsfälle in Spielen

Eine Armee von Klonen, die Ihnen folgt, kann viele faszinierende Spielmechaniken ermöglichen:
* Der Schlangen-Effekt: Klone folgen Ihnen in einer Reihe, wie in Klassikern wie „Snake” oder „Tron Light Cycle”.
* Verstärkung: Jeder Klon repräsentiert einen Verbündeten, der an Ihrer Seite kämpft oder Sie bei Aufgaben unterstützt.
* Punkte sammeln: Klone könnten Gegenstände sammeln, die der Spieler nicht erreichen kann, oder als Lebensbalken fungieren.
* Visuelle Ästhetik: Eine Gruppe von Anhängern kann Ihr Spiel dynamischer und lebendiger wirken lassen.

Nachdem wir die Grundlagen verstanden haben, tauchen wir nun in die verschiedenen Techniken ein, wie Sie Ihre Klone dazu bringen, Ihnen zu folgen.

## Methode 1: Das direkte, aggressive Folgen (Am einfachsten, aber ungenau)

Dies ist die einfachste Methode, um Klone zum Folgen zu bringen. Sie eignet sich gut für schnelllebige Aktionen, bei denen Präzision nicht oberste Priorität hat oder Klone sich überlappen dürfen.

**Das Prinzip:** Jeder Klon richtet sich ständig auf den Haupt-Sprite aus und bewegt sich dann ein paar Schritte vorwärts.

**So programmieren Sie es:**

1. **Haupt-Sprite (Der Spieler):**
* Stellen Sie sicher, dass Ihr Haupt-Sprite (nennen wir ihn „Spieler”) sich mit den Pfeiltasten oder der Maus bewegen kann. Das ist der Sprite, dem die Klone folgen sollen.

2. **Klon-Sprite (Der Klon-Erzeuger und die Klone selbst):**
* Wählen Sie den Sprite aus, der geklont werden soll (z.B. „Gefolgsmann”).
* **Skript für den Original-Sprite (den Klon-Erzeuger):**
„`scratch
Wenn die grüne Flagge angeklickt wird
verstecke dich // Das Original soll meistens unsichtbar sein,
// da nur die Klone sichtbar agieren sollen.
wiederhole 10 mal // Erzeuge zum Beispiel 10 Klone
warte 0.1 Sekunden // Eine kleine Pause zwischen den Klonen
erzeuge Klon von [myself]
„`
Passen Sie die Anzahl der Klone und die Wartezeit nach Belieben an.

* **Skript für die Klone (dieses Skript wird von jedem Klon ausgeführt):**
„`scratch
Wenn ich als Klon entstehe
zeige dich // Klone sollen sichtbar sein
wiederhole fortlaufend
richte dich nach [Spieler] // Wichtig! Richte dich immer auf den Spieler aus
gehe 5 Schritte // Bewege dich 5 Schritte in Richtung des Spielers
„`

**Vorteile:**
* Extrem einfach zu implementieren.
* Gibt ein Gefühl von „Chaos” oder „Schwarm”, da Klone sich überlappen und drängeln.

**Nachteile:**
* Klone werden sich überlappen und alle auf der exakt gleichen Position des Spielers landen, wenn dieser stillsteht.
* Sie sehen möglicherweise nicht wie eine organisierte Armee aus, sondern eher wie ein Klumpen.
* Kann bei vielen Klonen zu Leistungsengpässen führen, wenn alle auf einer Stelle „zittern”.

## Methode 2: Das folgende mit Verzögerung (Der Schlangen-Effekt)

Diese Methode ist etwas komplexer, liefert aber einen viel organisierteren und optisch ansprechenderen „Schlangen”- oder „Gefolgschafts”-Effekt. Klone folgen nicht direkt dem Spieler, sondern einer Spur, die der Spieler hinterlässt.

**Das Prinzip:** Der Haupt-Sprite speichert seine Position (X und Y Koordinaten) ständig in einer Liste. Jeder Klon holt sich dann eine Position aus dieser Liste, die etwas weiter zurückliegt als die des vorangehenden Klons oder des Spielers selbst.

**So programmieren Sie es:**

1. **Erstellen Sie Listen:**
* Gehen Sie zu „Variablen” und klicken Sie auf „Liste erstellen”.
* Erstellen Sie zwei neue Listen: `X-Positionen` und `Y-Positionen`. Diese Listen werden die Koordinaten des Spielers speichern.

2. **Haupt-Sprite (Der Spieler):**
* **Skript zur Speicherung der Positionen:**
„`scratch
Wenn die grüne Flagge angeklickt wird
lösche alles aus [X-Positionen] // Listen bei Spielstart leeren
lösche alles aus [Y-Positionen]
wiederhole fortlaufend
füge [x Position] zu [X-Positionen] hinzu // Aktuelle X-Position speichern
füge [y Position] zu [Y-Positionen] hinzu // Aktuelle Y-Position speichern
// Optional: Begrenzen Sie die Größe der Liste, um die Leistung zu verbessern
// oder wenn Ihre „Schlange” nur eine bestimmte Länge haben soll.
// Wenn die Liste zu lang wird, löschen Sie alte Einträge.
wenn (Länge von [X-Positionen] > 50) dann // Beispiel: Maximal 50 Positionen
lösche (1) aus [X-Positionen]
lösche (1) aus [Y-Positionen]
warte 0.05 Sekunden // Wichtig! Eine kleine Verzögerung, damit die Klone
// die Bewegung wahrnehmen können. Passt die „Trägheit” an.
„`

3. **Klon-Sprite (Der Klon-Erzeuger und die Klone selbst):**
* **Skript für den Original-Sprite (den Klon-Erzeuger):**
„`scratch
Wenn die grüne Flagge angeklickt wird
verstecke dich
setze [Klon-ID] auf 0 // Eine Variable nur für diesen Sprite (nicht „für alle Sprites”)
wiederhole 10 mal // Erzeuge 10 Klone
ändere [Klon-ID] um 1 // Jeder Klon erhält eine einzigartige ID
erzeuge Klon von [myself]
warte 0.5 Sekunden // Zeit, damit der vorige Klon sich positionieren kann
„`
Die `Klon-ID` ist entscheidend, damit jeder Klon weiß, welcher Eintrag in der Liste er sich schnappen muss.

* **Skript für die Klone (dieses Skript wird von jedem Klon ausgeführt):**
„`scratch
Wenn ich als Klon entstehe
zeige dich
// Wartet, bis genug Positionen in der Liste sind, um dem Spieler zu folgen
warte bis (Länge von [X-Positionen] > (Klon-ID * 5)) // Passt den Multiplikator an
// Je höher, desto größer der Abstand
wiederhole fortlaufend
// Überprüfen, ob die Liste die benötigte Länge hat, sonst kann es Fehler geben
wenn (Länge von [X-Positionen] > (Klon-ID * 5)) dann
gehe zu x: (Element (Länge von [X-Positionen] – (Klon-ID * 5)) aus [X-Positionen])
y: (Element (Länge von [Y-Positionen] – (Klon-ID * 5)) aus [Y-Positionen])
sonst
// Falls die Liste zu kurz ist (z.B. am Anfang), folge direkt dem Spieler
gehe zu x: (x Position von [Spieler]) y: (y Position von [Spieler])

// Optional: Richte dich auch auf den Spieler aus, wenn du nicht direkt folgst,
// um die Rotation anzupassen.
// richte dich nach [Spieler] // Nur wenn Klone in Bewegungsrichtung zeigen sollen
„`
**Erklärung des Index:**
`Länge von [X-Positionen] – (Klon-ID * 5)`:
* `Länge von [X-Positionen]` gibt die aktuelle Größe der Liste zurück (die neueste Position ist am Ende).
* `Klon-ID` ist 1 für den ersten Klon, 2 für den zweiten usw.
* Der Multiplikator (hier `5`) bestimmt den Abstand zwischen den Klonen. Ein höherer Wert bedeutet mehr Abstand und eine „lockerere” Schlange.

**Vorteile:**
* Erzeugt einen sehr coolen, organisierten Schlangen- oder Verfolgungs-Effekt.
* Klone überlappen sich nicht direkt, sie bilden eine nachvollziehbare Linie.
* Sie können die „Trägheit” und den Abstand der Klone feinjustieren.

**Nachteile:**
* Etwas komplexer in der Einrichtung, da Listen und ID-Management erforderlich sind.
* Kann bei sehr vielen Klonen und sehr langen Listen die Leistung beeinflussen, wenn nicht optimiert.

## Methode 3: Folgen mit Abstandsregelung (Vermeidung von Überlappungen und Kollisionen)

Diese Methode kombiniert das direkte Folgen mit einem Mechanismus zur Vermeidung von Überlappungen. Klone versuchen, dem Spieler zu folgen, aber sie verlangsamen sich oder weichen aus, wenn sie zu nah herankommen.

**Das Prinzip:** Jeder Klon überprüft seinen Abstand zum Haupt-Sprite. Ist der Abstand zu gering, bewegt er sich langsamer oder stoppt. Ist er zu groß, beschleunigt er.

**So programmieren Sie es:**

1. **Klon-Sprite (Die Klone):**
* **Skript für die Klone:**
„`scratch
Wenn ich als Klon entstehe
zeige dich
wiederhole fortlaufend
richte dich nach [Spieler]
setze [Abstand_zum_Spieler] auf (Abstand zu [Spieler])

wenn ([Abstand_zum_Spieler] > 50) dann // Wenn der Spieler weit weg ist
gehe 5 Schritte // Schnell folgen
sonst wenn ([Abstand_zum_Spieler] > 20) dann // Wenn der Spieler näher ist
gehe (([Abstand_zum_Spieler]) / 5) Schritte // Geschwindigkeit proportional zum Abstand
// (Bewegt sich langsamer, je näher er kommt)
sonst // Wenn der Spieler zu nah ist (innerhalb 20 Pixeln)
gehe 0 Schritte // Stoppen oder:
// drehe dich (zufällige Zahl von -5 bis 5) Grad // Leichtes Zappeln
// oder: gehe -2 Schritte // Leichter Rückzug, um Abstand zu halten
„`
Die Werte `50` und `20` sind Beispiele und müssen an die Größe Ihrer Sprites und das gewünschte Verhalten angepasst werden. Der Divisor `5` bei der Geschwindigkeitsberechnung bestimmt, wie „glatt” die Annäherung ist.

**Vorteile:**
* Klone versuchen, einen gewissen Abstand zum Spieler zu halten.
* Wirkt organischer und weniger „verklumpt” als Methode 1.
* Bessere Kontrolle über die Positionierung der Klone.

**Nachteile:**
* Kann immer noch zu leichten Überlappungen oder „Tanzen” der Klone führen, wenn sie versuchen, den Abstand zu halten.
* Nicht so gut für einen geraden „Schlangen-Effekt” wie Methode 2.
* Benötigt Feinabstimmung der Schwellenwerte für den Abstand und die Geschwindigkeit.

## Methode 4: Hybride Ansätze und fortgeschrittene Konzepte

Die wahren Meisterwerke entstehen oft durch die Kombination der oben genannten Methoden oder die Einführung weiterer Elemente:

* **Kombination aus Liste und Abstandsregelung:** Klone folgen den Positionen in der Liste, aber wenn sie zu nah an den Spieler oder einen anderen Klon kommen (z.B. durch Kollisionserkennung), passen sie ihre Geschwindigkeit an oder weichen leicht aus. Dies erfordert komplexere Logik und oft „private” Variablen für jeden Klon (d.h. Variablen, die nicht „für alle Sprites” sind).
* **Zufällige Abweichung:** Um das Verhalten natürlicher wirken zu lassen, können Sie kleine Zufallskomponenten hinzufügen. Anstatt sich perfekt auszurichten, dreht sich der Klon z.B. um `(+/- 5 Grad zufällig)` um die Hauptrichtung.
* **Wandkollision:** Was passiert, wenn der Spieler durch eine Wand geht, die Klone aber nicht? Sie müssten eine Kollisionserkennung für Klone einbauen, die sie dazu bringt, um Hindernisse herumzugehen oder ihnen zu folgen. Dies ist ein Schritt in Richtung einfacher Pfadfindung.
* **Geschwindigkeit anpassen:** Klone könnten ihre Geschwindigkeit basierend auf der Geschwindigkeit des Haupt-Sprites anpassen, um die Kohärenz der Gruppe zu erhöhen.

## Optimierung und Performance-Tipps für große Klon-Armeen

Eine große Anzahl von Klonen kann die Leistung Ihres Scratch-Projekts beeinträchtigen, besonders auf älteren Geräten. Hier sind einige Tipps zur Optimierung:

* Klonanzahl begrenzen: Erzeugen Sie nicht mehr Klone, als Sie wirklich brauchen. Scratch hat eine Obergrenze von 300 Klonen pro Projekt.
* Skripte schlank halten: Je weniger Blöcke in den `wiederhole fortlaufend` Schleifen Ihrer Klone sind, desto besser. Vermeiden Sie komplexe Berechnungen in diesen Schleifen, wenn möglich.
* Verstecken statt Löschen: Wenn ein Klon nur temporär nicht benötigt wird, können Sie ihn verstecken, anstatt ihn zu löschen und später neu zu erstellen. Das spart Ressourcen. Wenn er dauerhaft weg soll, dann löschen Sie ihn.
* Grafik-Effekte sparsam einsetzen: Effekte wie „Ghost” oder „Fischauge” können rechenintensiv sein.
* Bühnenbild statisch halten: Wenn sich das Bühnenbild nicht bewegt, entlastet das die CPU.
* Listenmanagement: Bei Methode 2 halten Sie die Listen nicht unnötig lang. Löschen Sie alte Einträge, die nicht mehr benötigt werden.

## Praktische Anwendungen und Ideen für Ihre Klon-Armee

Nachdem Sie die Techniken beherrschen, lassen Sie uns überlegen, wo Sie Ihre Klon-Armee einsetzen könnten:

* Ein „Snake”-ähnliches Spiel: Der Spieler ist der Kopf der Schlange, und die Klone sind der Körper, der wächst, wenn man Futter isst.
* Ein Sammelspiel: Die Klone sammeln für Sie Münzen oder Schätze, die auf dem Spielfeld verstreut sind.
* Ein Kampfspiel: Die Klone sind Ihre treuen Begleiter, die an Ihrer Seite kämpfen und Feinde angreifen, die sich nähern.
* Ein Puzzle-Spiel: Jeder Klon hat eine bestimmte Fähigkeit, und Sie müssen sie in der richtigen Reihenfolge oder am richtigen Ort positionieren, um ein Rätsel zu lösen.
* Ein „Rette die Freunde”-Spiel: Sie retten Charaktere, und diese schließen sich Ihrer wachsenden Armee an, die Ihnen folgt.

Die Möglichkeiten sind endlos! Lassen Sie Ihrer Fantasie freien Lauf.

## Fazit: Die Macht der Klon-Armee in Ihrer Hand

Das Programmieren einer Klon-Armee, die Ihnen in Scratch folgt, ist ein fantastisches Projekt, das Ihnen nicht nur die grundlegenden Konzepte von Klonen näherbringt, sondern auch fortgeschrittenere Themen wie Listen, Schleifen und Abstandslogik. Von der einfachen, direkten Verfolgung bis hin zu komplexen, schlangenartigen Formationen – jede Methode bietet einzigartige visuelle Effekte und Spielmechaniken.

Experimentieren Sie mit den verschiedenen Techniken, passen Sie die Zahlen und Geschwindigkeiten an, und beobachten Sie, wie Ihre digitale Gefolgschaft zum Leben erwacht. Mit etwas Übung und Kreativität können Sie beeindruckende und interaktive Spiele in Scratch entwickeln, die Spieler begeistern. Viel Spaß beim Klone-Bauen und beim Erobern der Scratch-Welt mit Ihrer persönlichen Armee!