Einen Kreis zeichnen
Ein runder Turm, ein Brunnen, ein Ring aus Fackeln um den Spawn: Minecraft besteht aus Quadraten, aber ein Programm kann einen Kreis aus Blöcken mit beliebigem Radius um den Auslöserblock zeichnen. Es geht in kleinen Schritten einmal um den Kreis, macht mit COS und SIN aus jedem Winkel einen Punkt und setzt auf jeden Punkt einen Block.
Funktionen: SIN, COS, ROUND und die Konstante PI, mit PLACE_BLOCK und SAY aus c0de/minecraft
Braucht einen Operator
PLACE_BLOCK ohne inventory setzt Blöcke aus dem Nichts in die Welt, darum muss der Besitzer des Auslöserblocks ein Operator sein. In der Welt der Tutorials bist du einer. Auf einem Server kann der Administrator es mit allowBlockChanges=true in config/c0de.properties für alle erlauben; ohne dieses Recht stürzt das Programm mit PERMISSION_DENIED ab. Die Alternative für alle ist PLACE_BLOCK mit inventory: Es nimmt die Blöcke aus einer Truhe, wie ein Spieler – siehe die erste Übung.
Was du brauchst
Einen Auslöserblock mit einem Knopf auf ebenem Boden, mit etwas Platz drumherum. Wahlweise die Variablenkarten radius vom Typ INTEGER und block vom Typ STRING (eine Block-ID wie minecraft:oak_planks); ohne sie hat der Ring den Radius 5 und ist aus Steinziegeln. Für die erste Übung: eine Truhe mit 40 Steinziegeln oben auf dem Auslöserblock, und den Knopf an einer Seite des Auslöserblocks.
Die Idee
Ein Punkt auf einem Kreis mit dem Radius r um die Mitte ist x = r · cos(Winkel) und z = r · sin(Winkel). Wenn der Winkel von 0 bis zu einer vollen Drehung läuft, geht der Punkt einmal um den Kreis. Der Winkel ist im Bogenmaß, und eine volle Drehung ist 2 × PI.
Blöcke haben ganze Koordinaten, darum schiebt ROUND jeden Punkt auf den nächsten Block. Daraus folgen zwei Dinge:
- Genug Schritte. Der Kreis ist 2 × PI × r lang, etwa 6,3 × r Blöcke. Mit 8 × r Schritten liegen zwei Punkte weniger als einen Block auseinander, also hat der Ring keine Lücken.
- Kein Block doppelt. Bei so vielen Schritten landen benachbarte Punkte oft auf demselben Block. PLACE_BLOCK setzt einen Block nur in Luft (oder Gras, Wasser und andere ersetzbare Blöcke) und löst sonst INVALID_ARGUMENT aus, darum wird ein Punkt übersprungen, der derselbe ist wie der davor.
Die Rechnung
Die Funktion points rechnet nur, darum lässt sie sich ohne die Welt testen: Für den Radius 3 gibt sie 20 Abstände von der Mitte, von x: 3, z: 0 einmal herum bis x: 3, z: -1; für den Radius 1 die 8 Blöcke um die Mitte.
PROGRAM ringpoints
NOOP
INCLUDE c0de/math
STRUCT offset
BEGIN
x INTEGER
z INTEGER
END STRUCT
NOOP
FUNCTION points
PARAMETER radius INTEGER 3
RESULT spots ARRAY STRUCT offset
BEGIN
VARIABLE steps INTEGER
VARIABLE angle FLOAT
VARIABLE cosine FLOAT
VARIABLE sine FLOAT
VARIABLE spot STRUCT offset
VARIABLE count INTEGER
VARIABLE last INTEGER
ASSIGN steps 8 * radius ;
FOR i INTEGER 0 ; steps - 1 ;
BEGIN
ASSIGN angle 2 * c0de/math/PI * i / steps ;
CALL c0de/math/COS
PARAMETER value angle ;
RESULT result cosine
CALL c0de/math/SIN
PARAMETER value angle ;
RESULT result sine
CALL c0de/math/ROUND
PARAMETER value radius * cosine ;
RESULT result spot.x
CALL c0de/math/ROUND
PARAMETER value radius * sine ;
RESULT result spot.z
CALL LEN
PARAMETER value spots ;
RESULT result count
IF count = 0 ;
BEGIN
ASSIGN spots[0] spot ;
END
ELSE
BEGIN
ASSIGN last count - 1 ;
IF spot ≠ spots[last] AND spot ≠ spots[0] ;
BEGIN
ASSIGN spots[count] spot ;
END IF
END IF
END FOR
END FUNCTIONDer Ring in der Welt
Das Programm ring hat dieselbe Struktur und Funktion und dazu eine Funktion draw, die auf jeden Punkt einen Block setzt:
PROGRAM ring
NOOP
INCLUDE c0de/math
INCLUDE c0de/minecraft
STRUCT offset
BEGIN
x INTEGER
z INTEGER
END STRUCT
NOOP
FUNCTION points
PARAMETER radius INTEGER 3
RESULT spots ARRAY STRUCT offset
BEGIN
VARIABLE steps INTEGER
VARIABLE angle FLOAT
VARIABLE cosine FLOAT
VARIABLE sine FLOAT
VARIABLE spot STRUCT offset
VARIABLE count INTEGER
VARIABLE last INTEGER
ASSIGN steps 8 * radius ;
FOR i INTEGER 0 ; steps - 1 ;
BEGIN
ASSIGN angle 2 * c0de/math/PI * i / steps ;
CALL c0de/math/COS
PARAMETER value angle ;
RESULT result cosine
CALL c0de/math/SIN
PARAMETER value angle ;
RESULT result sine
CALL c0de/math/ROUND
PARAMETER value radius * cosine ;
RESULT result spot.x
CALL c0de/math/ROUND
PARAMETER value radius * sine ;
RESULT result spot.z
CALL LEN
PARAMETER value spots ;
RESULT result count
IF count = 0 ;
BEGIN
ASSIGN spots[0] spot ;
END
ELSE
BEGIN
ASSIGN last count - 1 ;
IF spot ≠ spots[last] AND spot ≠ spots[0] ;
BEGIN
ASSIGN spots[count] spot ;
END IF
END IF
END FOR
END FUNCTION
NOOP
FUNCTION draw
PARAMETER radius INTEGER 5
PARAMETER block STRING "minecraft:stone_bricks"
BEGIN
VARIABLE spots ARRAY STRUCT offset
VARIABLE here STRUCT c0de/minecraft/POSITION
VARIABLE problem ERROR
VARIABLE placed INTEGER
VARIABLE skipped INTEGER
CALL points
PARAMETER radius radius ;
RESULT spots spots
ASSIGN here.y PID.y ;
EACH spot spots
BEGIN
ASSIGN here.x PID.x + spot.x ;
ASSIGN here.z PID.z + spot.z ;
CALL c0de/minecraft/PLACE_BLOCK problem
PARAMETER position here ;
PARAMETER id block ;
IF problem.code = 0 ;
BEGIN
ASSIGN placed placed + 1 ;
END
ELSE
BEGIN
ASSIGN skipped skipped + 1 ;
END IF
END EACH
CALL c0de/minecraft/SAY
PARAMETER message placed ⊕ " blocks placed, " ⊕ skipped ⊕ " spots were taken" ;
END FUNCTIONSo baust und startest du es
- Setze den Auslöserblock auf ebenen Boden und einen Knopf daran.
- Stelle ihn auf das Programm
ringund die Funktiondrawein. Wenn du magst, lege die Kartenradiusundblockin sein Eingabeinventar. - Drück den Knopf. Block für Block wächst ein Ring aus Steinziegeln um den Auslöserblock, von oben gesehen im Uhrzeigersinn, angefangen im Osten. Am Ende sagt der Chat
40 blocks placed, 0 spots were taken.

Der Ring steht auf der Höhe des Auslöserblocks. Eine Stelle, an der schon ein Block steht, etwa ein Baum, wird übersprungen und gezählt.
So funktioniert es
angleist2 * c0de/math/PI * i / steps: ein Bruchteil einer vollen Drehung./gibt ein FLOAT, wie COS und SIN es brauchen.- COS und SIN geben eine Zahl von -1 bis 1; mal
radiusist das der Abstand von der Mitte. ROUND schreibt ihn direkt in die Elementespot.xundspot.zder Struktur. - Doppelte überspringen. Der neue Punkt wird mit dem letzten in der Liste verglichen und mit dem ersten, denn die letzten Schritte des Kreises kommen dort an, wo er angefangen hat. Strukturen werden Element für Element verglichen.
- Die ERROR-Variable in der CALL-Zeile fängt den Fehler von PLACE_BLOCK ab, damit eine besetzte Stelle das Programm nicht abstürzen lässt. Nach einem CALL ohne Fehler ist
problem.codewieder 0. - Nicht ganz symmetrisch. ROUND schickt ein ,5 zum geraden Nachbarn, und ein FLOAT liegt oft ein winziges Stück neben einem ,5. Manche Punkte eines kleinen Rings landen auf einem anderen Block als ihr Spiegelbild – geschlossen ist der Ring trotzdem.
Probier es selbst
- Baue den Ring ohne Operatorrechte: Nimm die Blöcke aus einer Truhe oben auf dem Auslöserblock.
Lösung
Der Parameter inventory von PLACE_BLOCK nennt die Truhe, eine POSITION einen Block über dem Auslöserblock. Füll die Truhe mit Steinziegeln (40 für den Radius 5) und setze den Knopf an eine Seite des Auslöserblocks. Wenn die Truhe leer ist, löst PLACE_BLOCK ITEM_MISSING aus, und die Stelle zählt als übersprungen.
PROGRAM chestring
NOOP
INCLUDE c0de/math
INCLUDE c0de/minecraft
STRUCT offset
BEGIN
x INTEGER
z INTEGER
END STRUCT
NOOP
FUNCTION points
PARAMETER radius INTEGER 3
RESULT spots ARRAY STRUCT offset
BEGIN
VARIABLE steps INTEGER
VARIABLE angle FLOAT
VARIABLE cosine FLOAT
VARIABLE sine FLOAT
VARIABLE spot STRUCT offset
VARIABLE count INTEGER
VARIABLE last INTEGER
ASSIGN steps 8 * radius ;
FOR i INTEGER 0 ; steps - 1 ;
BEGIN
ASSIGN angle 2 * c0de/math/PI * i / steps ;
CALL c0de/math/COS
PARAMETER value angle ;
RESULT result cosine
CALL c0de/math/SIN
PARAMETER value angle ;
RESULT result sine
CALL c0de/math/ROUND
PARAMETER value radius * cosine ;
RESULT result spot.x
CALL c0de/math/ROUND
PARAMETER value radius * sine ;
RESULT result spot.z
CALL LEN
PARAMETER value spots ;
RESULT result count
IF count = 0 ;
BEGIN
ASSIGN spots[0] spot ;
END
ELSE
BEGIN
ASSIGN last count - 1 ;
IF spot ≠ spots[last] AND spot ≠ spots[0] ;
BEGIN
ASSIGN spots[count] spot ;
END IF
END IF
END FOR
END FUNCTION
NOOP
FUNCTION draw
PARAMETER radius INTEGER 5
PARAMETER block STRING "minecraft:stone_bricks"
BEGIN
VARIABLE spots ARRAY STRUCT offset
VARIABLE here STRUCT c0de/minecraft/POSITION
VARIABLE chest STRUCT c0de/minecraft/POSITION
VARIABLE problem ERROR
VARIABLE placed INTEGER
VARIABLE skipped INTEGER
CALL points
PARAMETER radius radius ;
RESULT spots spots
ASSIGN here.y PID.y ;
ASSIGN chest.x PID.x ;
ASSIGN chest.y PID.y + 1 ;
ASSIGN chest.z PID.z ;
EACH spot spots
BEGIN
ASSIGN here.x PID.x + spot.x ;
ASSIGN here.z PID.z + spot.z ;
CALL c0de/minecraft/PLACE_BLOCK problem
PARAMETER position here ;
PARAMETER id block ;
PARAMETER inventory chest ;
IF problem.code = 0 ;
BEGIN
ASSIGN placed placed + 1 ;
END
ELSE
BEGIN
ASSIGN skipped skipped + 1 ;
END IF
END EACH
CALL c0de/minecraft/SAY
PARAMETER message placed ⊕ " blocks placed, " ⊕ skipped ⊕ " spots were taken or the chest was empty" ;
END FUNCTION- Was passiert mit
4 * radiusSchritten statt8 * radius?
Lösung
Der Kreis ist etwa 6,3 × r Blöcke lang, also liegen 4 × r Schritte etwa 1,6 Blöcke auseinander. Bei einem kleinen Radius trifft ROUND noch benachbarte Blöcke, bei einem größeren bekommt der Ring Lücken, wo ein Schritt über einen Block springt. Mehr Schritte kosten Zeit – eine Zeile pro Tick –, machen aber nie eine Lücke.
Mehr dazu
- Die Handbuchseiten von SIN, COS und ROUND, und der Konstante PI
- PLACE_BLOCK, Die Welt verändern und Besitzer und Berechtigungen
- Fehler: einen Fehler mit einer ERROR-Variable abfangen
- Programme in der Welt: wer die Welt verändern darf