Turtlegrafik

Wir wollen eine Klasse einführen, die in der üblichen Weise zur Erzeugung von Grafiken eingesetzt werden kann. Ein kleiner Roboter (die Turtle) trägt einen Stift und zeichnet in einem Grafikkontext, wenn er bewegt wird - jedenfalls dann, wenn der Stift "unten" ist. Die Turtle hat eine Position (x|y), eine Farbe c und einen Winkel alpha, der im mathematisch positiven Sinn ("gegen den Uhrzeigersinn") gegen die x-Achse gezählt wird. Außerdem muss die Turtle "wissen", ob sie gerade auf der Grafik sichtbar ist und ob der Stift unten ist. Unterschiedliche Konstruktoren stellen diese Werte ein bzw. stellen Vorgabewerte ein. Mithilfe verschiedener Befehle kann man die Turtle bewegen:

Der Turtle soll mit dem Konstruktor der Grafikkontext g übergeben werden, auf dem sie sich zeigen soll. Da nur bekannte Verfahren benutzt werden, können wir die Klasse direkt in Java angeben.

class Turtle
{
//------------------------- beschreibende Größen ----------------------------
double x, y, alpha, xHome, yHome;
Color c;
boolean stiftUnten, sichtbar;
Graphics g;

//------------------------- Konstruktoren ----------------------------------
public Turtle(Graphics g, int x, int y, Color c)
{
    this.g = g;
    this.x = x;
    this.y = y;
    this.c = c;
    alpha = 0; //Vorgabewerte
    stiftUnten = true;
    sichtbar = false;
    xHome = x;
    yHome = y;
}

//------------------------- penUp ---------------------------------------
public void penUp()
{
stiftUnten = false;
}

//------------------------- penDown -------------------------------------
public void penDown()
{
stiftUnten = true;
}

//------------------------- show ----------------------------------------
public void show()
{
    if (!sichtbar)
    {
      zeigeDich();
      sichtbar = true;
    }
}

//------------------------- hide ----------------------------------------
public void hide()
{
    if (sichtbar)
    {
      zeigeDich();
      sichtbar = false;
    }
}

//------------------------- turn -----------------------------------------
public void turn(double da)
{
    hide();
    alpha = alpha - Math.PI * da / 180; //Umrechnung Grad \uF0E0 rad
    while (alpha < 0)
    {
      alpha = alpha + 2 * Math.PI;
    }
    while (alpha > 360)
    {
      alpha = alpha - 2 * Math.PI;
    }
    show();
}

//------------------------- move ----------------------------------------
public void move(double da)
{
    hide(); //Turtle verstecken
    int xalt = (int) Math.round(x); //Position merken
    int yalt = (int) Math.round(y);
    x = x + da * Math.cos(alpha);
    y = y + da * Math.sin(alpha);
    if (stiftUnten)
    {
      g.drawLine(xalt, yalt,
      (int) Math.round(x), (int) Math.round(y));
    }
    show();
}

//------------------------- home -----------------------------------------
public void home()
{
    hide();
    x = xHome;
    y = yHome;
    show();
}

//------------------------- clear -----------------------------------------
public void clear(int breite, int hoehe) // Bild löschen
{
    hide();
    g.setColor(Color.black);
    g.drawRect(0, 0, breite, hoehe);
    g.setColor(Color.white);
    g.fillRect(2, 2, breite - 4, hoehe - 4);
    show();
}

//------------------------- clear2 -----------------------------------------
public void clear() // Bild löschen
{
clear((int)(2*xHome)-5,(int)(2*yHome));
}

//------------------------- Hilfsmethode-----------------------------
private void zeigeDich() //zeichnet die Turtle
{
    g.setXORMode(Color.white); //ab jetzt im XOR-Mode zeichnen
    g.setColor(c); //Turtlefarbe einstellen
    for (int i = 5; i < 11; i = i + 5) //wunder-wunder schön
    {
      double xs = x + i * Math.cos(alpha);
      double ys = y + i * Math.sin(alpha);
      double beta = alpha - Math.PI * 30 / 180;
      int x2 = (int) Math.round(xs - i * Math.cos(beta));
      int y2 = (int) Math.round(ys - i * Math.sin(beta));
      beta = Math.PI * 60 / 180 - alpha;
      int x3 = (int) Math.round(xs - i * Math.sin(beta));
      int y3 = (int) Math.round(ys - i * Math.cos(beta));
      int x1 = (int) Math.round(xs);
      int y1 = (int) Math.round(ys);
      g.drawLine(x1, y1, x2, y2);
      g.drawLine(x2, y2, x3, y3);
      g.drawLine(x3, y3, x1, y1);
    }
    g.drawLine( (int) Math.round(x), (int) Math.round(y),
    (int) Math.round(x + 10 * Math.cos(alpha)),
    (int) Math.round(y + 10 * Math.sin(alpha)));
    g.setPaintMode(); //im Normalmodus zeichnen
    g.setColor(Color.black); //ab jetzt Stiftfarbe schwarz
}

move(x)	bewegt die Turtle um die Strecke der Länge x in der augenblicklichen Richtung
turn(x)	dreht die Turtle auf der Stelle um x Grad
penUp()	hebt den Stift
penDown()	senkt den Stift ab
show()	zeichnet die Turtle
hide()	versteckt die Turtle
home()	schickt die Turtle zum Startpunkt
clear()	löscht den Zeichenbereich
moveTo(x,y)	schickt die Turtle zur angegebenen Position
turnTo(x,y)	dreht die Turtle auf den angegebenen Winkel

Zur Ordnungswirkung fundamentaler Ideen der Informatik am Beispiel der theoretischen Schulinformatik

Beispiel 3: LOGO für Arme

Eckart Modrow

Die Turtlegrafik