Rotierende Koordinaten nach dem Übersetzen

Question

Gibt es eine Möglichkeit, das Koordinatensystem tatsächlich zu drehen?

Ich möchte ständig x = x + 1 sagen können, aber den Kreis in verschiedenen Winkeln mit translate bewegen, ähnlich wie bei Turtle Graphics, und möchte die Y-Achse überhaupt nicht verwenden.

Ich habe die Rotate-Funktion ausprobiert, aber das rotiert nur das Objekt, nicht die Richtung, in der es sich bewegt, es sei denn, ich mache etwas falsches? und ich bin nicht vertraut mit Vektoren, nur um mit ihnen bequem zu arbeiten.

Vielen Dank im Voraus.

Answer 1

Denken Sie an die rotate() Funktion als Drehen der Kamera. Es dreht das Koordinatensystem, nur nicht so, wie Sie es nennen.

Eigentlich würde ich argumentieren, dass Turtle Graphics das Koordinatensystem überhaupt nicht dreht, es dreht die Turtle. Sie können dies tun, indem Sie den Überblick über einige Variablen zu halten und die Drehungen machen und Zeichnungen selbst:

float turtleX; 
float turtleY; 
float turtleHeading = 0; 

void setup() { 
    size(500, 500); 
    turtleX = width/3; 
    turtleY = height/4; 
} 

void draw() { 

    forward(100); 
    rotateTurtle(45); 
    forward(100); 
    rotateTurtle(45); 
    forward(100); 
    rotateTurtle(45); 
    forward(100); 
    rotateTurtle(45); 
    forward(100); 
    rotateTurtle(45); 
    forward(100); 
    rotateTurtle(45); 
    forward(100); 
    rotateTurtle(45); 
    forward(100); 

    noLoop(); 
} 

void forward(float amount) { 
    float newX = turtleX + cos(radians(turtleHeading)) * amount; 
    float newY = turtleY + sin(radians(turtleHeading)) * amount; 

    line(turtleX, turtleY, newX, newY); 
    ellipse(newX, newY, 10, 10); 
    turtleX = newX; 
    turtleY = newY; 
} 

void rotateTurtle(float degrees) { 
    turtleHeading += degrees; 
} 

Oder könnten Sie kapseln, dass eine Klasse mit:

Turtle turtle; 

void setup() { 
    size(500, 500); 
    turtle = new Turtle(width/3, height/4); 
} 

void draw() { 

    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 
    turtle.rotate(45); 
    turtle.forward(100); 


    noLoop(); 
} 

class Turtle { 

    float x; 
    float y; 
    float heading = 0; 

    public Turtle(float x, float y) { 
    this.x = x; 
    this.y = y; 
    } 

    void forward(float amount) { 
    float newX = x + cos(radians(heading)) * amount; 
    float newY = y + sin(radians(heading)) * amount; 

    line(x, y, newX, newY); 
    ellipse(newX, newY, 10, 10); 
    x = newX; 
    y = newY; 
    } 

    void rotate(float degrees) { 
    heading += degrees; 
    } 
} 

Dies ist nur ein grundlegendes Beispiel, aber hoffentlich zeigt es, wovon ich rede. Du könntest diese Klasse hinzufügen, um sie schicker zu machen, und du könntest sie sogar als Bibliothek importieren, wenn du dies zum Beispiel benutzt, um Schüler zu unterrichten und ihnen die Details der Klasse vor den Kopf zu werfen.

Aber ich würde einen Schritt zurück und fragen Sie, warum Sie diese Art von Sache verwenden möchten. Wenn du nur herumspielst, ist das cool, aber du solltest auch darüber nachdenken, etwas mehr in "Verarbeitung" zu denken. Die Verarbeitung verwendet ein absolutes Koordinatensystem anstelle eines relativen Turtle (oder Stiftes), und alle seine Funktionen sind in diesem Sinne konzipiert. Auf diese Weise einen anderen Denkstil zu erzwingen, besiegt den Zweck, imho.

Aber wie ich schon sagte, wenn du das nur spielst, dann ist das cool!