This page in English

Entfernung und Richtung ​

Ein Spielerfinder am Tor deiner Basis: Drück den Knopf, und der Chat sagt dir, wo jeder Spieler in der Nähe ist – „Alex is 7 blocks away, north-east, higher up“. Das Programm misst die gerade Entfernung, die Entfernung zu Fuß und die Richtung als einen Schritt entlang jeder Achse.

Funktionen: SQR, ABS und SGN, mit ROUND aus c0de/math und FIND_ENTITIES und SAY aus c0de/minecraft

Was du brauchst

Einen Auslöserblock mit einem Knopf. Um die Rechnung allein auszuprobieren: die Variablenkarten dx, dy und dz vom Typ FLOAT und sechs nicht initialisierte Karten. Für den Finder in der Welt: sonst nichts, und einen Freund (oder ein zweites Konto) zum Finden.

Die Idee ​

Minecraft zählt x nach Osten, z nach Süden und y nach oben. Der Unterschied zweier Positionen, dx, dy und dz, sagt alles über den Weg zwischen ihnen:

  • Die gerade Entfernung ist die Diagonale eines Quaders mit den Seiten dx, dy und dz. Nach Pythagoras ist ihr Quadrat dx² + dy² + dz², und SQR, die Quadratwurzel, macht daraus wieder Blöcke.
  • Die Entfernung zu Fuß, wenn du nur entlang der Achsen gehen kannst, addiert die Längen der drei Seiten. Eine Seite ist eine Länge, auch wenn sie negativ ist – 6 Blöcke nach Norden sind dz = -6 –, darum lässt ABS zuerst das Vorzeichen weg.
  • Die Richtung ist das Vorzeichen jeder Seite: SGN gibt -1, 0 oder 1. Diese drei Zahlen sind auch ein Schritt von einem Block auf den anderen zu: x + stepX, y + stepY, z + stepZ.

Die Rechnung ​

Zuerst die Rechnung allein, damit du sie mit Variablenkarten testen kannst:

c0de
PROGRAM compass
NOOP
INCLUDE c0de/math
NOOP
FUNCTION measure
    PARAMETER dx FLOAT
    PARAMETER dy FLOAT
    PARAMETER dz FLOAT
    RESULT distance FLOAT
    RESULT walk FLOAT
    RESULT stepX INTEGER
    RESULT stepY INTEGER
    RESULT stepZ INTEGER
    RESULT direction STRING
BEGIN
    VARIABLE size FLOAT
    CALL c0de/math/SQR
        PARAMETER value dx ^ 2 + dy ^ 2 + dz ^ 2 ;
        RESULT result distance
    CALL c0de/math/ABS
        PARAMETER value dx ;
        RESULT result size
    ASSIGN walk size ;
    CALL c0de/math/ABS
        PARAMETER value dy ;
        RESULT result size
    ASSIGN walk walk + size ;
    CALL c0de/math/ABS
        PARAMETER value dz ;
        RESULT result size
    ASSIGN walk walk + size ;
    CALL c0de/math/SGN
        PARAMETER value dx ;
        RESULT result stepX
    CALL c0de/math/SGN
        PARAMETER value dy ;
        RESULT result stepY
    CALL c0de/math/SGN
        PARAMETER value dz ;
        RESULT result stepZ
    IF stepZ = -1 ;
    BEGIN
        ASSIGN direction "north" ;
    END IF
    IF stepZ = 1 ;
    BEGIN
        ASSIGN direction "south" ;
    END IF
    IF stepX ≠ 0 AND stepZ ≠ 0 ;
    BEGIN
        ASSIGN direction direction ⊕ "-" ;
    END IF
    IF stepX = 1 ;
    BEGIN
        ASSIGN direction direction ⊕ "east" ;
    END IF
    IF stepX = -1 ;
    BEGIN
        ASSIGN direction direction ⊕ "west" ;
    END IF
    IF direction = "" ;
    BEGIN
        ASSIGN direction "above or below" ;
    END IF
END FUNCTION

Mit dx = 3, dy = 2 und dz = -6 sind die Ergebnisse distance = 7.0 (die Wurzel aus 9 + 4 + 36), walk = 11.0, die Schritte 1, 1 und -1 und direction = north-east. Mit dx = -4.5 und den anderen 0 sind es 4.5, 4.5 und west.

Der Finder in der Welt ​

Die Funktion measure kommt unverändert in ein Programm mit c0de/minecraft. find sucht Spieler um den Auslöserblock herum und fragt measure nach jedem von ihnen:

c0de
PROGRAM playerfinder
NOOP
INCLUDE c0de/math
INCLUDE c0de/minecraft
NOOP
FUNCTION measure
    PARAMETER dx FLOAT
    PARAMETER dy FLOAT
    PARAMETER dz FLOAT
    RESULT distance FLOAT
    RESULT walk FLOAT
    RESULT stepX INTEGER
    RESULT stepY INTEGER
    RESULT stepZ INTEGER
    RESULT direction STRING
BEGIN
    VARIABLE size FLOAT
    CALL c0de/math/SQR
        PARAMETER value dx ^ 2 + dy ^ 2 + dz ^ 2 ;
        RESULT result distance
    CALL c0de/math/ABS
        PARAMETER value dx ;
        RESULT result size
    ASSIGN walk size ;
    CALL c0de/math/ABS
        PARAMETER value dy ;
        RESULT result size
    ASSIGN walk walk + size ;
    CALL c0de/math/ABS
        PARAMETER value dz ;
        RESULT result size
    ASSIGN walk walk + size ;
    CALL c0de/math/SGN
        PARAMETER value dx ;
        RESULT result stepX
    CALL c0de/math/SGN
        PARAMETER value dy ;
        RESULT result stepY
    CALL c0de/math/SGN
        PARAMETER value dz ;
        RESULT result stepZ
    IF stepZ = -1 ;
    BEGIN
        ASSIGN direction "north" ;
    END IF
    IF stepZ = 1 ;
    BEGIN
        ASSIGN direction "south" ;
    END IF
    IF stepX ≠ 0 AND stepZ ≠ 0 ;
    BEGIN
        ASSIGN direction direction ⊕ "-" ;
    END IF
    IF stepX = 1 ;
    BEGIN
        ASSIGN direction direction ⊕ "east" ;
    END IF
    IF stepX = -1 ;
    BEGIN
        ASSIGN direction direction ⊕ "west" ;
    END IF
    IF direction = "" ;
    BEGIN
        ASSIGN direction "above or below" ;
    END IF
END FUNCTION
NOOP
FUNCTION find
    PARAMETER radius INTEGER 32
BEGIN
    VARIABLE here STRUCT c0de/minecraft/POSITION
    VARIABLE players ARRAY STRUCT c0de/minecraft/ENTITY
    VARIABLE distance FLOAT
    VARIABLE blocks INTEGER
    VARIABLE stepY INTEGER
    VARIABLE direction STRING
    VARIABLE height STRING
    ASSIGN here.x PID.x ;
    ASSIGN here.y PID.y ;
    ASSIGN here.z PID.z ;
    CALL c0de/minecraft/FIND_ENTITIES
        PARAMETER position here ;
        PARAMETER radius radius ;
        PARAMETER type "minecraft:player" ;
        RESULT result players
    EACH player players
    BEGIN
        CALL measure
            PARAMETER dx player.position.x - here.x ;
            PARAMETER dy player.position.y - here.y ;
            PARAMETER dz player.position.z - here.z ;
            RESULT distance distance
            RESULT stepY stepY
            RESULT direction direction
        CALL c0de/math/ROUND
            PARAMETER value distance ;
            RESULT result blocks
        ASSIGN height "" ;
        IF stepY = 1 ;
        BEGIN
            ASSIGN height ", higher up" ;
        END IF
        IF stepY = -1 ;
        BEGIN
            ASSIGN height ", further down" ;
        END IF
        CALL c0de/minecraft/SAY
            PARAMETER message player.name ⊕ " is " ⊕ blocks ⊕ " blocks away, " ⊕ direction ⊕ height ;
    END EACH
END FUNCTION

So baust und startest du es ​

  1. Stelle den Auslöserblock auf das Programm playerfinder und die Funktion find ein. Er braucht keine Karten: radius hat den Vorgabewert 32.
  2. Bitte deinen Freund, sich vom Auslöserblock zu entfernen, aber nicht mehr als 32 Blöcke, und vielleicht ein Stück hinaufzuklettern. Dann drück selbst den Knopf. (Oder umgekehrt: Du gehst weg, und dein Freund drückt.)
  3. Der Chat zeigt eine Zeile pro Spieler innerhalb von 32 Blöcken, etwa [playerfinder/0] Alex is 7 blocks away, north-east, higher up. Wer den Knopf gedrückt hat, steht auch auf der Liste, direkt neben dem Auslöserblock.

So funktioniert es ​

  • PID.x, PID.y und PID.z sind die Position des Auslöserblocks. here ist eine POSITION-Struktur mit ihnen, die Mitte für FIND_ENTITIES.
  • Die Unterschiede gehen direkt in die PARAMETER-Zeilen: player.position.x - here.x. measure nimmt FLOATs, und ein INTEGER passt von selbst in ein FLOAT.
  • dx ^ 2 quadriert einen Wert; die Summe ist nie negativ, darum löst SQR hier nie INVALID_ARGUMENT aus. Ohne das Quadrat würde es ein negativer Wert tun.
  • ABS und SGN zusammen zerlegen eine Zahl in ihre Größe und ihr Vorzeichen: size * sign ist wieder die Zahl.
  • Der Richtungstext setzt Norden oder Süden zuerst, dann Osten oder Westen, mit einem Strich nur, wenn es beides gibt. Für einen Spieler genau über oder unter dem Auslöserblock gibt es keine Himmelsrichtung.
  • RESULT-Zeilen wählen Ergebnisse aus. find braucht von measure nur distance, stepY und direction; die anderen werden weggeworfen.

Probier es selbst ​

  1. Eine Wachzone ist ein Würfel, keine Kugel: Ein Spieler ist drinnen, wenn er entlang jeder Achse höchstens size Blöcke weg ist. Schreib eine Funktion inside mit ABS.
Lösung

Jede der drei Entfernungen muss höchstens size sein. Mit dx = -8, dy = 3, dz = 10 und der vorgegebenen Größe 10 ist inside TRUE; mit dz = -11 ist es FALSE.

c0de
PROGRAM guardzone
NOOP
INCLUDE c0de/math
NOOP
FUNCTION inside
    PARAMETER dx FLOAT
    PARAMETER dy FLOAT
    PARAMETER dz FLOAT
    PARAMETER size INTEGER 10
    RESULT inside BOOLEAN
BEGIN
    VARIABLE ax FLOAT
    VARIABLE ay FLOAT
    VARIABLE az FLOAT
    CALL c0de/math/ABS
        PARAMETER value dx ;
        RESULT result ax
    CALL c0de/math/ABS
        PARAMETER value dy ;
        RESULT result ay
    CALL c0de/math/ABS
        PARAMETER value dz ;
        RESULT result az
    ASSIGN inside ax ≤ size AND ay ≤ size AND az ≤ size ;
END FUNCTION
  1. Warum ist walk (11 Blöcke) im Beispiel länger als distance (7 Blöcke) – und wann sind beide gleich?
Lösung

distance ist die gerade Linie durch die Luft, die Diagonale; walk geht an den Kanten des Quaders entlang, und das ist immer mindestens so lang. Gleich sind sie, wenn zwei der drei Unterschiede 0 sind, wie bei dx = -4.5 allein: Dann ist der Weg eine gerade Linie entlang einer Achse.

Mehr dazu ​