Die Welt des Programmierens ist faszinierend, besonders wenn es um das Erstellen interaktiver Geschichten und Spiele geht. Scratch, die visuelle Programmiersprache von MIT, hat Millionen von Kindern und Erwachsenen den Einstieg in diese Welt ermöglicht. Mit seinen intuitiven Bausteinen können selbst Anfänger komplexe Abläufe gestalten. Doch es gibt ein Phänomen, das viele Scratch 2-Nutzer zur Verzweiflung treibt: Man platziert eine Figur mit dem Befehl „gehe zu zufälliger Position“ oder nutzt den Baustein „Zufallszahl zwischen X und Y“ für die Koordinaten, startet das Projekt neu – und die Figur landet *immer wieder* an genau derselben Stelle! Ist das ein **Bug in Scratch 2**? Eine Fehlfunktion? Oder steckt mehr dahinter?
Dieser Artikel taucht tief in dieses Rätsel ein. Wir werden verstehen, warum dieses Verhalten auftritt, warum es kein echter Bug im herkömmlichen Sinne ist und vor allem: Wie Sie Ihre Scratch-Projekte so gestalten können, dass Ihre Figuren wirklich unvorhersehbar auf der Bühne erscheinen.
### Das Rätsel entschlüsselt: Was steckt hinter dem „Zufalls”-Phänomen in Scratch 2?
Stellen Sie sich vor, Sie bauen ein Spiel, in dem ein Raumschiff zufällig auf dem Bildschirm erscheinen soll, oder ein Fangspiel, bei dem Objekte immer an einer neuen, unvorhersehbaren Stelle auftauchen. Sie nutzen voller Überzeugung den Block „gehe zu zufälliger Position“ oder basteln sich mit „Zufallszahl von X bis Y“ eigene zufällige X- und Y-Koordinaten. Sie klicken auf die grüne Flagge, und siehe da – das Raumschiff erscheint links oben. Sie stoppen das Spiel und starten es neu. Und wieder: Links oben. Frustration macht sich breit. Was ist hier los?
Die kurze Antwort lautet: Es ist kein Fehler in Scratch, sondern ein fundamentales Konzept der Computerwissenschaft, das sich hinter dem Begriff **Pseudo-Zufallszahlengenerator (PRNG)** verbirgt. Computer können von Natur aus keinen „echten” Zufall erzeugen. Sie sind deterministische Maschinen, das heißt, sie führen Anweisungen immer auf dieselbe Weise aus. Um den Anschein von Zufälligkeit zu erwecken, verwenden sie Algorithmen, die Zahlenfolgen erzeugen, die *zufällig erscheinen*, aber in Wirklichkeit vorhersehbar sind, wenn man ihren Startpunkt kennt.
### Tiefenbohrung: Wie Computer „Zufall“ vortäuschen – Der PRNG und der „Seed“
Um das Verhalten in Scratch 2 zu verstehen, müssen wir uns ein wenig mit dem Konzept des **Pseudo-Zufallszahlengenerators (PRNG)** und dem sogenannten **„Seed“** (oder Startwert) befassen.
Stellen Sie sich einen PRNG wie ein Kochbuch für Zufallszahlen vor. Dieses Kochbuch hat eine feste Liste von Rezepten (Algorithmen), um eine unendlich lange Reihe von Zahlen zu generieren, die auf den ersten Blick chaotisch und unregelmäßig aussehen. Der Clou ist jedoch: Um mit dem Kochen der „Zufallszahlen“ zu beginnen, braucht das Kochbuch einen Startpunkt – den **„Seed“**.
* **Der Algorithmus:** Das ist die mathematische Formel, die aus dem aktuellen Wert den nächsten „zufälligen” Wert berechnet. Diese Formel ist fest und ändert sich nicht.
* **Der Seed (Startwert):** Dies ist der erste Wert, mit dem der Algorithmus „gefüttert“ wird. Jede Zahlenfolge, die ein PRNG erzeugt, ist *vollständig* durch ihren Seed bestimmt. Wenn Sie denselben Seed verwenden, erhalten Sie *immer* dieselbe Sequenz von „zufälligen” Zahlen.
**Beispiel:** Nehmen wir an, unser PRNG-Rezept ist ganz einfach: „Nimm die aktuelle Zahl, multipliziere sie mit 3, addiere 7 und nimm dann die letzte Ziffer.”
* Wenn der **Seed 1** ist:
* 1 * 3 + 7 = 10 -> letzte Ziffer: 0
* 0 * 3 + 7 = 7 -> letzte Ziffer: 7
* 7 * 3 + 7 = 28 -> letzte Ziffer: 8
* Die Sequenz beginnt: 0, 7, 8, …
* Wenn der **Seed 1** ist (erneut):
* 1 * 3 + 7 = 10 -> letzte Ziffer: 0
* 0 * 3 + 7 = 7 -> letzte Ziffer: 7
* Die Sequenz ist wieder: 0, 7, 8, …
Sie sehen das Muster: Derselbe Seed führt zur selben Folge. Computerprogramme müssen also einen Weg finden, ihren Seed zu ändern, um wirklich unvorhersehbare Ergebnisse zu liefern. Oft wird dafür die **Systemzeit** des Computers in Millisekunden verwendet, da diese sich ständig ändert.
### Scratch 2.0 und das Seed-Problem
Genau hier liegt der Schlüssel zum Verständnis des „Bugs” in Scratch 2.0:
1. **Seed-Initialisierung bei Programmstart:** Wenn Sie ein Scratch-Projekt laden oder Scratch 2.0 öffnen und ein neues Projekt starten, wird der interne Pseudo-Zufallszahlengenerator von Scratch mit einem Startwert (Seed) initialisiert. Dieser Seed basiert oft auf der aktuellen **Systemzeit** des Computers zum Zeitpunkt des Starts.
2. **Deterministisches Verhalten bei gleichem Startpunkt:** Wenn Sie Ihr Scratch-Projekt schließen und direkt danach wieder öffnen und auf die grüne Flagge klicken, ist es sehr wahrscheinlich, dass die Systemzeit zum Zeitpunkt des erneuten Starts nahezu identisch ist. Oder, und das ist ein häufiger Fall: Wenn die Uhrzeit nicht ausreichend granular für den Seed genutzt wird, oder wenn Scratch aus irgendeinem Grund bei jedem Programmstart einen *festen* Standard-Seed verwendet, führt dies dazu, dass die erzeugte „zufällige” Zahlenfolge von vorne beginnt und somit die erste Zufallszahl (und damit die Position Ihrer Figur) *immer dieselbe* ist.
3. **Variabilität innerhalb einer Session:** Wenn Sie das Projekt einmal gestartet haben und dann *innerhalb derselben Scratch-Sitzung* immer wieder die grüne Flagge drücken, werden Sie feststellen, dass Ihre Figuren *unterschiedliche* zufällige Positionen einnehmen! Das liegt daran, dass der PRNG seinen internen Zustand nach jeder generierten Zahl aktualisiert. Die Zahlenfolge läuft also weiter, und bei jedem Neustart innerhalb der Session wird die nächste Zahl in der **fortlaufenden Sequenz** verwendet. Das Problem tritt also primär dann auf, wenn Scratch 2.0 oder das Projekt **frisch gestartet** wird und der Seed auf einen bekannten/fixen Wert zurückgesetzt wird.
**Kurz gesagt:** Der „Bug” tritt auf, weil der PRNG bei einem **neuen Start** der Scratch-Anwendung oder des Projekts (nach dem Schließen und Wiederöffnen) immer wieder mit demselben oder einem sehr ähnlichen Seed initialisiert wird, was dazu führt, dass die *erste* generierte „zufällige” Zahl (und damit die Startposition) immer dieselbe ist.
### Szenarien, in denen dieser „Bug“ oft auftritt:
* **Initialisierung der Figurposition:** Sie wollen, dass ein Hauptcharakter bei jedem Start des Spiels an einer anderen, zufälligen Stelle beginnt.
* **Objekt-Spawning:** In einem Spiel sollen neue Feinde oder Sammelobjekte an zufälligen Orten auftauchen, aber beim Testen erscheinen sie immer wieder an derselben ersten Position.
* **Simulationen:** Wenn Sie eine Simulation erstellen, die von zufälligen Startbedingungen abhängt, und diese Bedingungen nach einem Neustart immer identisch sind.
### Die „Lösung”: Wie Sie echten Zufall (oder zumindest bessere Unvorhersehbarkeit) erzielen!
Da wir nun das Problem verstanden haben, können wir uns den Lösungen zuwenden. Da wir den Seed von Scratch 2.0 nicht direkt beeinflussen können, müssen wir indirekte Methoden anwenden, um die „zufällige” Zahlenfolge zu „stören” oder zu „initialisieren”, damit der erste sichtbare Wert nicht immer der gleiche ist.
#### Methode 1: Das „Aufwärmen” des Zufallszahlengenerators (Pre-RNG-Seeding)
Die effektivste Methode ist, den Zufallszahlengenerator dazu zu bringen, ein paar „nutzlose” Zufallszahlen zu erzeugen, bevor Sie die erste *sichtbare* Zufallszahl für Ihre Figurenposition generieren. Dadurch wird der PRNG in der Sequenz weiter vorangetrieben, und die dann verwendete Zahl ist nicht mehr die erste deterministische.
**So geht’s in Scratch:**
„`scratch
wenn grüne Flagge angeklickt wird
// Schritt 1: Zufallszahlengenerator „aufwärmen”
wiederhole 10 mal
gehe zu x: (Zufallszahl von -1000 bis 1000) y: (Zufallszahl von -1000 bis 1000) // Diese Zahlen werden unsichtbar außerhalb der Bühne erzeugt
warte (0.01) Sekunden // Eine kleine Wartezeit, falls das System zu schnell ist
// Schritt 2: Figur an wirklich zufällige Position setzen
gehe zu x: (Zufallszahl von -240 bis 240) y: (Zufallszahl von -180 bis 180)
zeige dich // Falls die Figur vorher versteckt war
„`
**Erklärung:** Die Schleife „wiederhole 10 mal“ generiert zehn Paare von Zufallszahlen für X- und Y-Koordinaten. Da die Werte von -1000 bis 1000 außerhalb der sichtbaren Bühne liegen, sehen Sie die Figur während dieses „Aufwärmens” nicht. Erst danach wird die eigentliche sichtbare Startposition generiert. Da der PRNG jetzt 10 (oder mehr) Zahlen weiter in seiner Sequenz ist, ist die Chance, dass die sichtbare Startposition beim Neustart des Projekts (nach dem Schließen und Öffnen von Scratch) dieselbe ist, extrem gering. Sie erhalten so eine deutlich bessere **Verteilung der Startpositionen**.
#### Methode 2: Externe „Zufalls-Treiber” nutzen
Sie können auch externe, sich ständig ändernde Werte nutzen, um die Berechnung Ihrer Zufallszahlen zu beeinflussen. Der **Timer**-Block oder die **Mausposition** sind hierfür hervorragend geeignet.
**Beispiel mit Timer:**
„`scratch
wenn grüne Flagge angeklickt wird
setze x auf (Zufallszahl von -240 bis 240)
setze y auf (Zufallszahl von -180 bis 180)
// Zusätzliche „Rauschen” hinzufügen basierend auf dem Timer
gehe zu x: (x + (Zufallszahl von (-Timer) bis (Timer))) y: (y + (Zufallszahl von (-Timer) bis (Timer)))
// ODER noch einfacher, wenn der Timer als Seed-Einfluss genutzt werden soll:
// (Diese Methode ist eher experimentell, da der Timer schnell sehr groß wird)
// setze Variable „Basiswert” auf (Timer)
// gehe zu x: (Zufallszahl von -240 bis 240) y: (Zufallszahl von -180 bis 180) // Erste Zufallszahl
// dann modifiziere die Position um einen kleinen Zufallswert, der vom Timer abhängt:
// ändere x um (Zufallszahl von (-5) bis (5)) // Simuliert zusätzliches „Rauschen”
// ändere y um (Zufallszahl von (-5) bis (5))
„`
Die Methode mit dem Timer ist subtiler und sollte eher als ein Weg gesehen werden, **zusätzliche Unvorhersehbarkeit** hinzuzufügen, indem sie die interne Sequenz des PRNG beeinflusst, da der `Timer` bei jedem Programmstart einen anderen Wert hat. Die `Zufallszahl` Blöcke werden trotzdem neu berechnet, aber der Einfluss des Timers (oder der Mausposition) macht die Startpositionen variabler. Die „Aufwärm”-Methode (Methode 1) ist in der Regel effektiver, um den Seed-Effekt zu umgehen.
#### Methode 3: Indirekte Zufallssteuerung über Benutzerinteraktion
Wenn die Startposition nicht *sofort* bei Programmstart zufällig sein muss, sondern erst nach einer Benutzeraktion, können Sie dies nutzen.
**Beispiel:**
„`scratch
wenn grüne Flagge angeklickt wird
verstecke dich
sage [Klicke auf mich, um zu starten!] für (2) Sekunden
wenn diese Figur angeklickt wird
gehe zu zufälliger Position
zeige dich
„`
In diesem Fall hängt die erste zufällige Position von der **genauen Zeit** ab, zu der der Benutzer auf die Figur klickt. Da dies jedes Mal leicht variieren wird, ist die resultierende Position viel unvorhersehbarer als bei einem sofortigen Start.
#### Methode 4: Mehrere Zufallszahlen generieren und eine davon auswählen
Diese Methode ist eine Variation des „Aufwärmens”, kann aber auch genutzt werden, um eine Auswahl aus mehreren Zufallswerten zu treffen.
„`scratch
wenn grüne Flagge angeklickt wird
setze [zufalls_x_liste] auf [] // Eine leere Liste erstellen
setze [zufalls_y_liste] auf []
// Fülle die Listen mit vielen Zufallszahlen
wiederhole 100 mal
füge (Zufallszahl von -240 bis 240) zu [zufalls_x_liste] hinzu
füge (Zufallszahl von -180 bis 180) zu [zufalls_y_liste] hinzu
// Wähle eine zufällige Position aus den generierten Listen
setze [index] auf (Zufallszahl von 1 bis (Länge von [zufalls_x_liste]))
gehe zu x: (Element (index) von [zufalls_x_liste]) y: (Element (index) von [zufalls_y_liste])
„`
Diese Methode ist aufwendiger, stellt aber sicher, dass Sie aus einer großen Menge von bereits generierten Zufallszahlen wählen, deren anfängliche Deterministik durch die Masse der Generierung verwischt wird.
### Best Practices für den Umgang mit Zufallszahlen in Scratch
* **Verstehen Sie den PRNG:** Erinnern Sie sich immer daran, dass Computer keinen echten Zufall erzeugen. Dies hilft Ihnen, unerwartetes Verhalten zu deuten.
* **Generieren Sie Zufall, wenn er benötigt wird:** Platzieren Sie den „Zufallszahl“-Block nicht unnötig weit vom Ereignis entfernt, das ihn auslösen soll.
* **Testen Sie gründlich:** Wenn Zufälligkeit in Ihrem Projekt wichtig ist, testen Sie es mehrmals – nicht nur durch Klicken auf die grüne Flagge in einer Sitzung, sondern auch durch Schließen und erneutes Öffnen des Projekts und sogar der Scratch-Anwendung selbst.
* **Nutzen Sie die `Zufallsposition` klug:** Der Block „gehe zu zufälliger Position“ ist praktisch, unterliegt aber denselben PRNG-Prinzipien wie die manuelle Generierung von Zufalls-Koordinaten. Die „Aufwärm”-Methode kann auch hier angewendet werden.
### Über Scratch 2.0 hinaus: Ein Blick auf Scratch 3.0 und andere Sprachen
Das beschriebene Verhalten ist keine Besonderheit von Scratch 2.0. Auch in anderen Programmiersprachen müssen Entwickler bewusst mit PRNGs umgehen. Python hat zum Beispiel ein `random`-Modul, das eine `seed()`-Funktion bietet, um den Startwert explizit zu setzen. Wenn Sie `random.seed()` nicht aufrufen, wird oft die Systemzeit als Standard-Seed verwendet.
In **Scratch 3.0**, der aktuellen Online-Version und Offline-Editor, ist das Verhalten des Zufallszahlengenerators optimiert worden. Die zugrunde liegende JavaScript-Engine (`Math.random()`) nutzt in der Regel robustere Methoden zur Seed-Generierung (oft basierend auf verschiedenen Systemparametern und einem besser verteilten Zufall) und einen komplexeren PRNG, sodass der Effekt des immer gleichen Startpunkts seltener auftritt oder weniger auffällig ist. Dennoch bleibt das Grundprinzip der Pseudo-Zufälligkeit bestehen. Für die meisten Scratch 3.0-Nutzer ist das Problem der festen Startposition daher weniger relevant. Für Scratch 2.0-Projekte, die oft offline oder in älteren Bildungsumgebungen genutzt werden, bleibt es jedoch eine wichtige Überlegung.
### Fazit: Kein Bug, sondern eine Lektion in Informatik
Der „Scratch 2-Bug”, bei dem Ihre Figuren trotz vermeintlicher Zufälligkeit immer an der gleichen Stelle landen, ist kein Softwarefehler, sondern eine wunderbare Lehrstunde in den Grundlagen der Informatik. Er zeigt uns, dass Computer nicht „würfeln” können, sondern Anweisungen folgen müssen, um den Anschein von Unvorhersehbarkeit zu erzeugen.
Durch das Verständnis des Konzepts von **Pseudo-Zufallszahlengeneratoren (PRNG)** und ihres **Seeds** können Sie die scheinbare „Voreingenommenheit” Ihrer Scratch 2-Projekte überwinden. Mit einfachen Techniken wie dem **”Aufwärmen” des Zufallszahlengenerators** stellen Sie sicher, dass Ihre Spiele und Simulationen bei jedem Start wirklich neue, unvorhersehbare Ergebnisse liefern. Das macht Ihre Projekte nicht nur dynamischer und spannender, sondern vermittelt Ihnen auch ein tieferes Verständnis dafür, wie Software unter der Haube funktioniert. Also, keine Panik mehr beim nächsten scheinbar nicht-zufälligen Start – Sie wissen jetzt, wie Sie das Rätsel lösen können!