Willkommen, liebe Minecraft-Architekten und Kommando-Block-Zauberer! Habt ihr euch jemals gefragt, wie ihr das aufregende Kinderspiel „Rotes Licht, Grünes Licht” (im englischen Original „Red Light, Green Light” bekannt, auch populär durch die Serie Squid Game) in eurer eigenen Minecraft-Welt nachbilden könnt? Stellt euch vor: Ihr steht mit euren Freunden an der Startlinie, die Spannung steigt, und dann die Aufforderung: „Grünes Licht!” – alle rennen los. Doch wehe dem, der sich noch bewegt, wenn der Ruf „Rotes Licht!” ertönt und die „Puppe” sich umdreht!
Dieses Minispiel ist nicht nur ein garantierter Spaß für Multiplayer-Server, sondern auch eine fantastische Möglichkeit, eure Kenntnisse im Umgang mit Minecrafts **Kommando-Blöcken** und **Scoreboards** zu vertiefen. In diesem umfassenden Guide führen wir euch Schritt für Schritt durch die Erstellung dieses spannenden Spiels, von den grundlegenden Konzepten bis hin zu den komplexen Befehlsketten. Lasst uns eintauchen!
Die Grundlagen des Spiels: Regeln, Rollen und das Ziel
Bevor wir uns in die technischen Details stürzen, lassen wir uns die Spielregeln noch einmal vergegenwärtigen, die wir in Minecraft nachbilden wollen:
* **Spielerzahl:** Ideal für 2+ Spieler. Einer ist die „Puppe” (oder „Es”), die anderen sind die „Läufer”.
* **Spielfeld:** Ein langer, offener Bereich mit einer Startlinie und einer Ziellinie.
* **Spielablauf:**
* Die Puppe steht an der Ziellinie, mit dem Rücken zu den Läufern, und ruft: „Grünes Licht!”
* Während „Grünes Licht” aktiv ist, dürfen sich die Läufer auf die Puppe zubewegen.
* Nach einer zufälligen (oder festgelegten) Zeit ruft die Puppe: „Rotes Licht!” und dreht sich sofort zu den Läufern um.
* Sobald „Rotes Licht” ertönt und die Puppe sich umgedreht hat, müssen alle Läufer **sofort stillstehen**.
* Jeder Läufer, der sich bewegt, während „Rotes Licht” aktiv ist und die Puppe zugewandt ist, wird „gefangen” und scheidet aus dem Spiel aus.
* Die Puppe dreht sich nach einer kurzen Wartezeit wieder weg und ruft erneut „Grünes Licht!”.
* **Ziel:** Die Läufer versuchen, die Ziellinie zu erreichen, ohne gefangen zu werden. Die Puppe gewinnt, wenn alle Läufer gefangen wurden.
Vorbereitung in Minecraft: Die Bühne ist bereit!
Bevor wir einen einzigen Befehl eingeben, bereiten wir unsere Spielwelt vor.
1. **Welt erstellen:** Erstellt eine neue Minecraft-Welt im Kreativmodus. Stellt sicher, dass Cheats aktiviert sind! (Esc -> Im LAN öffnen -> Cheats erlauben: EIN).
2. **Spielfeld bauen:**
* **Startlinie:** Definiert einen Bereich, an dem alle Läufer das Spiel beginnen.
* **Spielfläche:** Eine lange, flache Fläche, die zur Ziellinie führt. Achtet auf genügend Platz, da die **Bewegungserkennung** auf kleineren Flächen schwierig zu kalibrieren sein könnte.
* **Ziellinie:** Ein eindeutiger Block oder Bereich, den die Läufer erreichen müssen.
* **Aus-Bereich:** Ein separater Bereich, wohin gefangene Spieler teleportiert werden.
3. **Kommando-Blöcke erhalten:** Gebt `/give @s command_block` in den Chat ein, um euren ersten **Kommando-Block** zu erhalten. Platziert sie an einem versteckten Ort, z.B. unter dem Spielfeld oder in einem geschlossenen Raum daneben.
Die Werkzeuge: Kommando-Blöcke und Scoreboards
Der Kern unseres Minispiels sind **Kommando-Blöcke** und **Scoreboards**.
* **Kommando-Blöcke:** Diese Blöcke können Minecraft-Befehle ausführen. Wir werden hauptsächlich drei Typen verwenden:
* **Impuls (Impulse):** Führt einen Befehl einmal aus, wenn er aktiviert wird (z.B. durch einen Knopf).
* **Kette (Chain):** Führt einen Befehl aus, nachdem der vorherige Ketten-Kommando-Block in der Reihe ausgelöst wurde. Sie sind oft „Bedingt” (Conditional), was bedeutet, dass sie nur ausgeführt werden, wenn der vorherige Block erfolgreich war.
* **Wiederholen (Repeating):** Führt einen Befehl wiederholt aus, sobald er aktiviert ist (normalerweise immer aktiv). Dies ist unser Hauptwerkzeug für Spiel-Loops.
Alle wiederholenden und Ketten-Kommando-Blöcke sollten auf „Immer aktiv” (Always Active) eingestellt werden, es sei denn, ihr wollt sie manuell steuern.
* **Scoreboards:** Mit **Scoreboards** können wir verschiedene Aspekte des Spiels verfolgen und verwalten:
* Spieler-Status (ist jemand die Puppe? Ist jemand gefangen?).
* Spielphasen (Grünes Licht, Rotes Licht, Spielende).
* Timer (wie lange ist Grünes Licht aktiv?).
* Spieler-Koordinaten (für die Bewegungserkennung).
Schritt-für-Schritt-Anleitung: Die Kommando-Ketten
Beginnen wir mit der Implementierung! Platziert die Kommando-Blöcke so, dass sie leicht zugänglich sind und ihr ihre Funktion erkennen könnt. Eine gute Praxis ist es, Wiederholungs-Kommando-Blöcke an den Anfang einer Kette zu setzen, gefolgt von vielen Ketten-Kommando-Blöcken.
1. Scoreboards einrichten
Zuerst müssen wir alle benötigten **Scoreboard-Ziele** erstellen. Öffnet den Chat und gebt diese Befehle ein:
„`
/scoreboard objectives add gamePhase dummy
/scoreboard objectives add greenTimer dummy
/scoreboard objectives add redTimer dummy
/scoreboard objectives add isMoving dummy
/scoreboard objectives add lastX dummy
/scoreboard objectives add lastY dummy
/scoreboard objectives add lastZ dummy
/scoreboard objectives add currentX dummy
/scoreboard objectives add currentY dummy
/scoreboard objectives add currentZ dummy
/scoreboard objectives add isDoll dummy
/scoreboard objectives add caughtPlayers dummy
/scoreboard objectives add reachedEnd dummy
„`
* `gamePhase`: Verwaltet den Spielstatus (0=Idle/Setup, 1=Grünes Licht, 2=Rotes Licht, 3=Spiel beendet).
* `greenTimer`: Zählt die Zeit für die „Grünes Licht”-Phase.
* `redTimer`: Zählt die Zeit für die „Rotes Licht”-Phase.
* `isMoving`: Setzt sich auf 1, wenn ein Spieler sich bewegt, sonst auf 0.
* `lastX`, `lastY`, `lastZ`: Speichern die Position eines Spielers vom vorherigen Tick.
* `currentX`, `currentY`, `currentZ`: Speichern die aktuelle Position eines Spielers.
* `isDoll`: 1 für die Puppe, 0 für Läufer.
* `caughtPlayers`: Zählt die Anzahl der gefangenen Spieler.
* `reachedEnd`: Zählt die Anzahl der Spieler, die die Ziellinie erreicht haben.
2. Spielerrollen zuweisen und initialisieren
Einmalig vor Spielstart: Wählt einen Spieler als Puppe aus. Alle anderen sind Läufer.
**Kommando-Block 1 (Impuls, Bedarf Redstone): Start-/Reset-Knopf**
Platziert einen Knopf auf diesen Block.
`scoreboard players set #game gamePhase 0`
*Beschreibung:* Setzt die Spielphase auf 0 (Idle/Setup). Dies ist der Master-Reset.
**Kommando-Block 2 (Kette, Bedingt, Immer aktiv): Initialisiere Spieler**
`tag @a remove doll`
`tag @a remove runner`
`scoreboard players set @a isDoll 0`
`scoreboard players set @a isMoving 0`
`scoreboard players set @a caughtPlayers 0`
`scoreboard players set @a reachedEnd 0`
`scoreboard players set #game greenTimer 0`
`scoreboard players set #game redTimer 0`
*Beschreibung:* Entfernt alle Tags und setzt alle relevanten Scoreboard-Werte zurück.
**Kommando-Block 3 (Kette, Immer aktiv): Puppe zuweisen**
`tag @p add doll`
*Beschreibung:* Der Spieler, der den Knopf drückt, wird zur Puppe. Ihr könntet auch `/tag
**Kommando-Block 4 (Kette, Immer aktiv): Läufer zuweisen**
`execute as @a[tag=!doll] run tag @s add runner`
*Beschreibung:* Alle Spieler, die nicht die Puppe sind, erhalten das Tag „runner”.
**Kommando-Block 5 (Kette, Immer aktiv): Score „isDoll” setzen**
`execute as @a[tag=doll] run scoreboard players set @s isDoll 1`
`execute as @a[tag=runner] run scoreboard players set @s isDoll 0`
*Beschreibung:* Setzt den „isDoll”-Score für Puppe und Läufer.
**Kommando-Block 6 (Kette, Immer aktiv): Teleport zur Startlinie**
`execute as @a[tag=runner] run tp @s
*Beschreibung:* Teleportiert alle Läufer zur Startlinie. Ersetzt `
**Kommando-Block 7 (Kette, Immer aktiv): Puppe drehen und teleportieren**
`execute as @a[tag=doll] run tp @s
*Beschreibung:* Teleportiert die Puppe an ihre Startposition an der Ziellinie und lässt sie sich von den Läufern wegdrehen (Blickrichtung 180 Grad).
**Kommando-Block 8 (Kette, Immer aktiv): Spielstart signalisieren**
`tellraw @a {„text”:”Das Spiel ‘Rotes Licht, Grünes Licht’ beginnt!”,”color”:”gold”}`
`tellraw @a[tag=doll] {„text”:”Du bist die Puppe! Dreh dich weg und rufe ‘Grünes Licht!'”,”color”:”red”}`
`tellraw @a[tag=runner] {„text”:”Renne, wenn Grünes Licht ist! Stehe still bei Rotes Licht!”,”color”:”green”}`
**Kommando-Block 9 (Kette, Immer aktiv): Phase auf Grünes Licht setzen**
`scoreboard players set #game gamePhase 1`
*Beschreibung:* Leitet die erste „Grünes Licht”-Phase ein.
3. Das Bewegungserkennungssystem
Dies ist das Herzstück des Spiels und erfordert mehrere Kommando-Blöcke. Es vergleicht die aktuelle Position eines Spielers mit seiner Position im letzten Spiel-Tick.
**Kommando-Block 10 (Wiederholen, Immer aktiv): Aktuelle X-Koordinate speichern**
`execute as @a[tag=runner] at @s store result score @s currentX run data get entity @s Pos[0] 100`
*Beschreibung:* Speichert die aktuelle X-Koordinate jedes Läufers im Scoreboard `currentX`. Der Faktor 100 skaliert die Dezimalwerte zu ganzen Zahlen, um eine höhere Präzision zu erhalten.
**Kommando-Block 11 (Kette, Immer aktiv): Aktuelle Y-Koordinate speichern**
`execute as @a[tag=runner] at @s store result score @s currentY run data get entity @s Pos[1] 100`
**Kommando-Block 12 (Kette, Immer aktiv): Aktuelle Z-Koordinate speichern**
`execute as @a[tag=runner] at @s store result score @s currentZ run data get entity @s Pos[2] 100`
**Kommando-Block 13 (Kette, Immer aktiv): Bewegung in X-Richtung erkennen**
`execute as @a[tag=runner,scores={isMoving=0}] if score @s currentX != @s lastX run scoreboard players set @s isMoving 1`
*Beschreibung:* Wenn die `currentX`-Koordinate eines Läufers (der noch nicht als bewegt markiert ist) von `lastX` abweicht, wird `isMoving` auf 1 gesetzt.
**Kommando-Block 14 (Kette, Immer aktiv): Bewegung in Y-Richtung erkennen**
`execute as @a[tag=runner,scores={isMoving=0}] if score @s currentY != @s lastY run scoreboard players set @s isMoving 1`
*Beschreibung:* Dies erfasst Springen, Fallen oder Bewegen auf Treppen.
**Kommando-Block 15 (Kette, Immer aktiv): Bewegung in Z-Richtung erkennen**
`execute as @a[tag=runner,scores={isMoving=0}] if score @s currentZ != @s lastZ run scoreboard players set @s isMoving 1`
**Kommando-Block 16 (Kette, Immer aktiv): Letzte X-Koordinate aktualisieren**
`execute as @a[tag=runner] run scoreboard players operation @s lastX = @s currentX`
*Beschreibung:* Kopiert die aktuelle X-Koordinate in `lastX` für den nächsten Tick-Vergleich.
**Kommando-Block 17 (Kette, Immer aktiv): Letzte Y-Koordinate aktualisieren**
`execute as @a[tag=runner] run scoreboard players operation @s lastY = @s currentY`
**Kommando-Block 18 (Kette, Immer aktiv): Letzte Z-Koordinate aktualisieren**
`execute as @a[tag=runner] run scoreboard players operation @s lastZ = @s currentZ`
*Hinweis:* Diese Kette läuft ständig, muss aber nur während der „Rotes Licht”-Phase auswerten, ob sich ein Spieler bewegt. Die eigentliche Bestrafung erfolgt in Phase 2.
4. Die Spielphasen (Grün, Rot, Ende)
Dies ist die zentrale Spiellogik, die in einem wiederholenden Zyklus ausgeführt wird.
**Kommando-Block 19 (Wiederholen, Immer aktiv): Grünes Licht – Timer inkrementieren**
`execute if score #game gamePhase matches 1 run scoreboard players add #game greenTimer 1`
**Kommando-Block 20 (Kette, Immer aktiv): Grünes Licht – Doll wegdrehen**
`execute if score #game gamePhase matches 1 run execute as @a[tag=doll] run tp @s ~ ~ ~ 180 0`
*Beschreibung:* Die Puppe dreht sich von den Läufern weg.
**Kommando-Block 21 (Kette, Immer aktiv): Grünes Licht – Ansage bei Start der Phase**
`execute if score #game gamePhase matches 1 if score #game greenTimer matches 1 run tellraw @a {„text”:”Grünes Licht! Lauft!”,”color”:”green”}`
**Kommando-Block 22 (Kette, Immer aktiv): Grünes Licht – Ende des Timers**
`execute if score #game gamePhase matches 1 if score #game greenTimer matches 60..140 run scoreboard players set #game gamePhase 2`
*Beschreibung:* Nach 3-7 Sekunden (60-140 Ticks) wechselt das Spiel zu „Rotes Licht”. `60..140` ist ein Beispiel für einen zufälligen Timer-Bereich; für feste Zeiten wählt z.B. `matches 100`.
**Kommando-Block 23 (Kette, Immer aktiv): Rotes Licht – Timer inkrementieren und resetten**
`execute if score #game gamePhase matches 2 run scoreboard players add #game redTimer 1`
`execute if score #game gamePhase matches 2 if score #game redTimer matches 1 run scoreboard players set #game greenTimer 0`
*Beschreibung:* Startet den „Rotes Licht”-Timer und setzt den „Grünes Licht”-Timer zurück.
**Kommando-Block 24 (Kette, Immer aktiv): Rotes Licht – Doll umdrehen**
`execute if score #game gamePhase matches 2 run execute as @a[tag=doll] run tp @s ~ ~ ~ 0 0`
*Beschreibung:* Die Puppe dreht sich zu den Läufern um (Blickrichtung 0 Grad).
**Kommando-Block 25 (Kette, Immer aktiv): Rotes Licht – Ansage bei Start der Phase**
`execute if score #game gamePhase matches 2 if score #game redTimer matches 1 run tellraw @a {„text”:”Rotes Licht! Steht still!”,”color”:”red”}`
**Kommando-Block 26 (Kette, Immer aktiv): Rotes Licht – Bewegung checken und fangen**
`execute as @a[tag=runner,scores={isMoving=1},scores={isDoll=0}] if score #game gamePhase matches 2 run tag @s add caught`
*Beschreibung:* Während „Rotes Licht” und wenn ein Läufer sich bewegt, erhält er das Tag „caught”.
**Kommando-Block 27 (Kette, Immer aktiv): Gefangene Spieler teleportieren**
`execute as @a[tag=caught] run tp @s
`execute as @a[tag=caught] run gamemode spectator @s`
*Beschreibung:* Teleportiert gefangene Spieler in einen Zuschauerbereich und setzt sie in den Zuschauermodus.
**Kommando-Block 28 (Kette, Immer aktiv): Gefangene Spieler zählen und entfernen**
`execute as @a[tag=caught] run scoreboard players add #game caughtPlayers 1`
`execute as @a[tag=caught] run tag @s remove caught`
`execute as @a[tag=caught] run tag @s remove runner`
*Beschreibung:* Erhöht den Zähler für gefangene Spieler und entfernt das „caught”-Tag sowie das „runner”-Tag, damit sie nicht erneut gefangen werden.
**Kommando-Block 29 (Kette, Immer aktiv): Rotes Licht – Ende des Timers**
`execute if score #game gamePhase matches 2 if score #game redTimer matches 40 run scoreboard players set #game gamePhase 1`
*Beschreibung:* Nach 2 Sekunden (40 Ticks) geht es zurück zu „Grünes Licht”.
**Kommando-Block 30 (Kette, Immer aktiv): isMoving zurücksetzen für nächste Runde**
`execute if score #game gamePhase matches 1 run scoreboard players set @a isMoving 0`
*Beschreibung:* Setzt den „isMoving”-Score für alle Läufer zu Beginn jeder „Grünes Licht”-Phase zurück. Wichtig, damit sie in der nächsten „Rotes Licht”-Phase wieder erfasst werden können.
5. Start- und End-Trigger
Wir brauchen noch Möglichkeiten, das Spiel zu beenden.
**Kommando-Block 31 (Wiederholen, Immer aktiv): Ziellinie erreichen**
`execute as @a[tag=runner] at @s if block ~ ~-1 ~
*Beschreibung:* Wenn ein Läufer einen speziellen Zielblock unter sich hat, erhält er das Tag „finished”. Ersetzt `
**Kommando-Block 32 (Kette, Immer aktiv): Gewinner ansagen**
`execute as @a[tag=finished] run tellraw @a {„text”:”HERZLICHEN GLÜCKWUNSCH! „,”color”:”gold”},{„selector”:”@s”},{„text”:” hat die Ziellinie erreicht!”,”color”:”gold”}`
`execute as @a[tag=finished] run scoreboard players add #game reachedEnd 1`
`execute as @a[tag=finished] run tag @s remove runner`
`execute as @a[tag=finished] run tag @s remove finished`
`execute as @a[tag=finished] run gamemode spectator @s`
`execute as @a[tag=finished] run tp @s
**Kommando-Block 33 (Wiederholen, Immer aktiv): Spielende – alle gefangen oder am Ziel**
`execute if score #game gamePhase matches 1..2 if score #game caughtPlayers >=
`execute if score #game gamePhase matches 1..2 if score #game reachedEnd >= 1 run scoreboard players set #game gamePhase 3`
*Beschreibung:* Das Spiel endet, wenn alle Läufer gefangen wurden oder mindestens einer die Ziellinie erreicht hat. Ersetzt `
**Kommando-Block 34 (Kette, Immer aktiv): Spielende Ansage**
`execute if score #game gamePhase matches 3 if score #game redTimer matches 1 run tellraw @a {„text”:”Das Spiel ist beendet!”,”color”:”aqua”}`
`execute if score #game gamePhase matches 3 if score #game redTimer matches 2 run tellraw @a {„text”:”Ein neuer Durchgang kann gestartet werden.”,”color”:”aqua”}`
*Beschreibung:* Informiert die Spieler über das Ende des Spiels.
6. Anpassungen und Erweiterungen
Euer Grundgerüst steht! Hier sind Ideen zur Personalisierung:
* **Zufällige Timer:** Anstatt fester Timer könnt ihr mit `/scoreboard players set #game greenTimer
* **Soundeffekte:** Fügt Befehle wie `/playsound minecraft:block.note_block.harp master @a` hinzu, um „Grünes Licht” und „Rotes Licht” zu untermalen.
* **Partikel:** Verleiht der Puppe Partikeleffekte, wenn sie sich umdreht.
* **Schwierigkeitsgrade:** Passt die Dauer von „Grünes Licht” und „Rotes Licht” an, um das Spiel leichter oder schwerer zu machen.
* **Doll-KI:** Anstatt nur starr 0 oder 180 Grad zu schauen, könnte die Puppe zufällig in verschiedene Richtungen schauen oder versuchen, den nächsten Spieler ins Visier zu nehmen (komplexer).
* **Respawn:** Ihr könntet gefangene Spieler in den Abenteuermodus versetzen anstatt in den Zuschauermodus, damit sie zumindest zuschauen können.
Optimierung und Fehlerbehebung
* **Versteckt die Kommando-Blöcke:** Baut sie in einem separaten Raum oder unter der Erde, damit sie das Spielerlebnis nicht stören.
* **Lesbarkeit:** Beschriftet eure Kommando-Blöcke oder verwendet Schilder, um den Zweck jeder Kette zu dokumentieren.
* **Lags minimieren:** Zu viele aktive `execute` Befehle, insbesondere mit `@a` Selektoren, können die Performance beeinträchtigen. Versucht, Befehle zu optimieren, wo es geht. Zum Beispiel, indem ihr bestimmte Befehle nur in der relevanten Spielphase ausführt.
* **Testen:** Testet das Spiel gründlich mit mehreren Spielern, um Bugs zu finden und zu beheben. Achtet besonders auf die Bewegungserkennung!
* **Debuggen:** Nutzt den Befehl `/gamerule commandBlockOutput false`, um den Chat nicht mit Kommando-Block-Nachrichten zu überfluten. Bei Problemen könnt ihr ihn wieder aktivieren.
Fazit
Ihr habt es geschafft! Mit diesem Guide könnt ihr euer eigenes **”Rotes Licht, Grünes Licht”-Minispiel** in Minecraft erstellen. Es mag auf den ersten Blick komplex erscheinen, aber mit Geduld und systematischem Vorgehen werdet ihr bald eure Freunde in diesem spannenden Multiplayer-Erlebnis fangen können. Das Beherrschen von **Kommando-Blöcken** und **Scoreboards** öffnet euch unzählige Türen, um eure Minecraft-Welt mit eigenen Spielmechaniken und interaktiven Erlebnissen zu bereichern.
Viel Spaß beim Bauen, Spielen und Fangen! Und vergesst nicht: Bei „Rotes Licht” – bloß nicht bewegen!