This page in English

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.

c0de
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 FUNCTION

Der Ring in der Welt ​

Das Programm ring hat dieselbe Struktur und Funktion und dazu eine Funktion draw, die auf jeden Punkt einen Block setzt:

c0de
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 FUNCTION

So baust und startest du es ​

  1. Setze den Auslöserblock auf ebenen Boden und einen Knopf daran.
  2. Stelle ihn auf das Programm ring und die Funktion draw ein. Wenn du magst, lege die Karten radius und block in sein Eingabeinventar.
  3. 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.
a ring of stone bricks with the radius 5 on flat grass around a trigger block with a button, seen from above at an angle

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 ​

  • angle ist 2 * 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 radius ist das der Abstand von der Mitte. ROUND schreibt ihn direkt in die Elemente spot.x und spot.z der 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.code wieder 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 ​

  1. 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.

c0de
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
  1. Was passiert mit 4 * radius Schritten statt 8 * 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 ​