Bruder braucht Hilfe bei Java

[Mr.Bombastic]

Guten Abend,

ich zitiere ihn einfach direkt mal:

Schreiben Sie eine ausführbare Klasse, die, gesteuert von einer Zeichenkette, einen
Polygonzugs zeichnet. Der Polygonzug beginnt im Ursprung des Koordinatensystems
und der Zeichenstift ist in Richtung der positiven x-Achse orientiert.

Die Zeichenkette
enthält nur die Buchstaben F, L und R.

F Bewege den Zeichenstift um die Länge 1 in die Richtung, in die der Zeichenstift
orientiert ist und zeichne dabei eine Linie.
L Drehe den Zeichenstift um 90 nach links.
R Drehe den Zeichenstift um 90 nach rechts.

Soweit hab ich alles verstanden!
Doch die eigentliche Aufgabenstellung danach macht mir zu schaffen.

Dem eigentlichen Zeichnen geht eine Simulation voran, die die Groe des Polygonzugs
ermittelt, d.h. die maximale/minimale x-/y-Koordinaten bestimmt,
und die Skalierung des angezeigten Koordinatensystems so festlegt, dass der
komplette Polygonzug sichtbar ist.
Der Polygonzug wird mit Hilfe der Methoden
Klasse StdDraw gezeichnet.

Wie man eine Fenster bei Java erzeugt weiß ich mittlerweile, nur verstehe ich nicht wie ich das ganze in Java-Code zusammenfassen soll.
Mein Ansatzpunkt wäre der :

Java Code: Quelltext in neuem Fenster öffnen

    class Hint {
    public static void main ( String [] args ) {
    int count = StdIn . readInt ();
    StdIn . readLine ();
    char [] str = new char[ count ];
    for(int i = 0; i < count ; i++)
    str [i] = StdIn . readChar ();
    StdIn . readLine ();
    }
    }

Er ließt quasi die Anzahl der Zeichen und die Zeichen nacheinander von der
Standardeingabe.

Nur wie erzeuge ich ein Polygonzug laut der Aufgabenstellung ? Wäre echt lieb wenn ihr helfen würdet

Liebe Grüße

Das dicke ist seine Nachricht an euch. Wäre froh wenn ihr ihm helfen könntet, und einfach eure Idee postet. Hier ist die Aufgabe als PDF (Seite 5).


Liebe Grüße.

[Nuebel]

Da ich die angesprochene Klasse StdDraw nicht kenne, habe ich eine ganz einfache eigene Turtle-Klasse geschrieben:

class Turtle {

	private int x;

	private int y;

	private double angle;



	public Turtle() {

		x = y = 0;

		angle = 0.0d;

	}



	public void move(int x, int y) {

		this.x = x;

		this.y = y;

	}



	public void forward(int length) {

		final double radAngle = Math.toRadians(angle);

		final int endX = (int) Math.round(x + Math.cos(radAngle) * length);

		final int endY = (int) Math.round(y + Math.sin(radAngle) * length);

		move(endX, endY);

	}



	public void turnLeft(double angle) {

		this.angle -= angle;

	}



	public void turnRight(double angle) {

		this.angle += angle;

	}



	public final int    getX()     { return x; }

	public final int    getY()     { return y;	}

	public final double getAngle() { return angle; }

}

Für "FLFLFRFLFLFRFRF" bekomme ich folgende Ausgabe:

Spoiler:Restlicher Code

import java.awt.Graphics;

import java.awt.Dimension;



import javax.swing.SwingUtilities;

import javax.swing.JFrame;

import javax.swing.JPanel;



public class TurtleGraphicsDemo {

	public static void main(String[] args) {

		SwingUtilities.invokeLater(new Runnable() {

			@Override

			public void run() {

				final JFrame frame = new JFrame("Turtle Graphics Demo");

				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);



				final GraphicsPanel panel = new GraphicsPanel();

				panel.setPreferredSize(new Dimension(500, 300));

				panel.setTurtleCommands("FLFLFRFLFLFRFRF"); 



				frame.add(panel);



				frame.pack();

				frame.setLocationRelativeTo(null);

				frame.setVisible(true);

			}

		});

	}

}



class GraphicsPanel extends JPanel {

	private String turtleCommands;



	public GraphicsPanel() {

		super();

		turtleCommands = "";

	}



	public void setTurtleCommands(String turtleCommands) {

		this.turtleCommands = turtleCommands;

	}



	@Override

	protected void paintComponent(Graphics g) {

		super.paintComponent(g);

		

		final Turtle turtle = new Turtle();

		centerTurtle(turtle);



		for (char command : turtleCommands.toCharArray()) {

			if ('F' == command) {

				final int startX = turtle.getX();

				final int startY = turtle.getY();

				turtle.forward(50);

				g.drawLine(startX, startY, turtle.getX(), turtle.getY());

			}

			else if ('L' == command)

				turtle.turnLeft(90);

			else 

				turtle.turnRight(90);

		}

	}



	private void centerTurtle(Turtle turtle) {

		final Dimension size = getPreferredSize();

		turtle.move(size.width / 2, size.height / 2);

	}

}

Um vor dem Zeichnen die Bounds zu ermitteln, musst du im Eingabestring die Zeichen zählen. Nach einem (oder allgemeiner ungerade Anzahl von) L oder R wird die Richtung umgeschaltet (also von width auf height und vice versa). Du musst nur einen Fall besonders berücksichtigen. Wenn es eine 180°-Drehung gibt, also zwei L oder R hintereinander. Das heißt, du musst die Anzahl der Fs bei einem Winkel von 0° von der Anzahl der Fs bei einem Winkel von 180° (und so weiter) abziehen.