From ec82c46552acac549885256e69a010fba8e25ee3 Mon Sep 17 00:00:00 2001 From: biryuk <biryuk@exchange.informatik.uni-hamburg.de> Date: Sun, 23 Jan 2022 16:21:26 +0100 Subject: [PATCH] =?UTF-8?q?F=C3=BCge=20Code=20hinzu?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dompteur.java | 72 +++++++++ Turtle.java | 406 ++++++++++++++++++++++++++++++++++++++++++++++++++ bluej.pkg | 44 ++++++ package.bluej | 44 ++++++ 4 files changed, 566 insertions(+) create mode 100644 Dompteur.java create mode 100644 Turtle.java create mode 100644 bluej.pkg create mode 100644 package.bluej diff --git a/Dompteur.java b/Dompteur.java new file mode 100644 index 0000000..c2cb32b --- /dev/null +++ b/Dompteur.java @@ -0,0 +1,72 @@ +/** + * Exemplare dieser Klasse veranlassen Turtles dazu, + * Spuren auf einer Zeichenflaeche zu hinterlassen. + * + * @author Till Aust + * @author Axel Schmolitzky + * @version 26. November 2005 + */ +class Dompteur +{ + /** + * Der leere explizite Konstruktor von Dompteur. + */ + public Dompteur() + { + + } + + /** + * 'SE1' auf die Zeichenflaeche zeichnen. + */ + public void start() + { + // Neue Turtle an Position (50, 100) erzeugen. + Turtle turtle = new Turtle(50, 100); + + // 'S' zeichnen: + turtle.geheVor(30); + turtle.drehe(-90); + turtle.geheVor(30); + turtle.drehe(-90); + turtle.geheVor(30); + turtle.drehe(90); + turtle.geheVor(30); + turtle.drehe(90); + turtle.geheVor(30); + + // Ohne Spur zum naechsten Buchstaben bewegen: + turtle.hinterlasseKeineSpur(); + turtle.geheZu(130, 100); + + // 'E' zeichnen: + turtle.hinterlasseSpur(); + turtle.drehe(-180); + turtle.geheVor(30); + turtle.drehe(90); + turtle.geheVor(30); + turtle.drehe(90); + turtle.geheVor(30); + turtle.drehe(-180); + turtle.geheVor(30); + turtle.drehe(90); + turtle.geheVor(30); + turtle.drehe(90); + turtle.geheVor(30); + + // Ohne Spur zum naechsten Buchstaben bewegen: + turtle.hinterlasseKeineSpur(); + turtle.geheZu(180, 100); + + // '1' zeichnen: + turtle.hinterlasseSpur(); + turtle.setzeFarbe("rot"); + turtle.drehe(-90); + turtle.geheVor(60); + turtle.drehe(-120); + turtle.geheVor(20); + } + + //Hier wird zeichneNEck implementiert + +} diff --git a/Turtle.java b/Turtle.java new file mode 100644 index 0000000..6493655 --- /dev/null +++ b/Turtle.java @@ -0,0 +1,406 @@ +import java.awt.BasicStroke; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Graphics2D; +import java.awt.RenderingHints; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.awt.image.BufferedImage; + +import javax.swing.JFrame; +import javax.swing.JPanel; + +import java.util.HashMap; + +/** + * Diese Klasse definiert Turtles, die mit einfachen + * Operationen "bewegt" werden koennen. Die Bewegungen + * einer Turtle koennen auf einer Zeichenflaeche sichtbar + * gemacht werden, die Turtle hinterlaesst quasi eine + * Spur. Die Turtle selbst ist nicht sichtbar. + * <br><br> + * Warum gerade eine Turtle, also eine Schildkroete? + * Hauptsaechlich aufgrund der Programmiersprache LOGO, mit + * der die Idee der Turtle Graphics bekannt geworden ist. + * Etwas mehr Hintergrund ist hier zu finden: + * http://llk.media.mit.edu/projects/circles/turtles.html + * + * @author Original von Alfred Hermes (14.12.2003) + * @author Simon Gerlach + * @author Axel Schmolitzky + * @author Fredrik Winkler + * @author Clara Marie Lueders + * @version 5. Dezember 2018 + */ +public class Turtle +{ + // Position dieser Turtle + private double _xPos; + private double _yPos; + + // Richtung dieser Turtle + private double _richtung; + + // Die Farbe der Spur, die diese Turtle hinterlaesst + private Color _farbe; + + // Gibt an, ob diese Turtle eine Spur hinterlaesst oder nicht + private boolean _spurHinterlassen; + + // Reaktionszeit einer Turtle auf Befehle + private int _verzoegerung; + + // Moegliche Farbwerte + private static final HashMap<String, Color> FARBEN; + private static final Color[] FARB_ARRAY; + + static + { + FARBEN = new HashMap<String, Color>(); + FARBEN.put("schwarz", Color.BLACK); + FARBEN.put("blau", Color.BLUE); + FARBEN.put("cyan", Color.CYAN); + FARBEN.put("dunkelgrau", Color.DARK_GRAY); + FARBEN.put("grau", Color.GRAY); + FARBEN.put("gruen", Color.GREEN); + FARBEN.put("hellgrau", Color.LIGHT_GRAY); + FARBEN.put("magenta", Color.MAGENTA); + FARBEN.put("orange", Color.ORANGE); + FARBEN.put("pink", Color.PINK); + FARBEN.put("rot", Color.RED); + FARBEN.put("weiss", Color.WHITE); + FARBEN.put("gelb", Color.YELLOW); + FARB_ARRAY = FARBEN.values().toArray(new Color[FARBEN.size()]); + } + + /** + * Initialisiert eine neue Turtle auf den Mittelpunkt der Welt. + * Die Ausrichtung ist nach rechts (0 Grad), + * und es wird eine schwarze Spur hinterlassen. + */ + public Turtle() + { + this(TurtleWelt.WIDTH / 2, TurtleWelt.HEIGHT / 2); + } + + /** + * Loescht alle Spuren, die die Turtle bisher hinterlassen hat. + */ + public void loescheAlleSpuren() + { + TurtleWelt.GLOBALEWELT.loescheAlleSpuren(); + } + + /** + * Initialisiert eine neue Turtle auf einen gegebenen Startpunkt. + * Die Ausrichtung ist nach rechts (0 Grad), + * und es wird eine schwarze Spur hinterlassen. + * @param x die X-Koordinate + * @param y die Y-Koordinate + */ + public Turtle(double x, double y) + { + _xPos = x; + _yPos = y; + _richtung = 0; + _verzoegerung = 1; + _farbe = Color.BLACK; + _spurHinterlassen = true; + } + + /** + * Bewegt die Turtle vorwaerts in Blickrichtung. + * @param schritte Anzahl der Pixel, die die Turtle zuruecklegen + * soll + */ + public void geheVor(double schritte) + { + double radians = Math.toRadians(_richtung); + double nextX = _xPos + Math.cos(radians) * schritte; + double nextY = _yPos + Math.sin(radians) * schritte; + geheZu(nextX, nextY); + } + + /** + * Bewegt die Turtle auf einer Linie zu einer neuen Position. + * @param x X-Koordinate der neuen Position + * @param y Y-Koordinate der neuen Position + */ + public void geheZu(double x, double y) + { + if (_spurHinterlassen) + { + TurtleWelt.GLOBALEWELT.zeichneLinie(_xPos, _yPos, x, y, _farbe); + } + _xPos = x; + _yPos = y; + verzoegern(); + } + + /** + * Setzt die Blickrichtung der Turtle. + * @param winkel 0 = rechts, 90 = unten, 180 = links, 270 = oben + */ + public void setzeRichtung(double winkel) + { + _richtung = winkel; + verzoegern(); + } + + /** + * Dreht die Turtle um eine angegebene Winkeldifferenz. + * @param winkel zu drehende Winkeldifferenz in Grad + */ + public void drehe(double winkel) + { + setzeRichtung(_richtung + winkel); + } + + /** + * Laesst die Turtle auf den angegebenen Punkt (x, y) schauen. + * @param x X-Koordinate + * @param y Y-Koordinate + */ + public void schaueAuf(double x, double y) + { + double deltaX = x - _xPos; + double deltaY = y - _yPos; + setzeRichtung(Math.toDegrees(Math.atan2(deltaY, deltaX))); + } + + /** + * Setzt die Farbe der Spur, die diese Turtle hinterlaesst. + * Moegliche Farben sind "schwarz", "blau", "cyan", "dunkelgrau", + * "grau", "gruen", "hellgrau", "magenta", "orange", "pink", "rot", "weiss", "gelb". + * @param neueFarbe die neue Spur-Farbe der Turtle + */ + public void setzeFarbe(String neueFarbe) + { + if ((neueFarbe == null) || ((_farbe = FARBEN.get(neueFarbe.toLowerCase())) == null)) + { + _farbe = Color.BLACK; + } + } + + /** + * Setzt eine der 13 moeglichen Farben. + * @param farbnummer die Farbummer (0 = schwarz, 12 = gelb) + */ + public void setzeFarbe(int farbnummer) + { + _farbe = FARB_ARRAY[Math.abs(farbnummer % 13)]; + } + + /** + * Bewegungen der Turtle sind ab sofort unsichtbar. + */ + public void hinterlasseKeineSpur() + { + _spurHinterlassen = false; + } + + /** + * Bewegungen der Turtle sind ab sofort sichtbar. + */ + public void hinterlasseSpur() + { + _spurHinterlassen = true; + } + + /** + * Setzt die Geschwindigkeit, mit der die Turtle auf Anweisungen reagiert. + * @param geschwindigkeit von 0 (langsam) bis 10 (schnell) + */ + public void setzeGeschwindigkeit(int geschwindigkeit) + { + if (geschwindigkeit > 10) + { + geschwindigkeit = 10; + } + else if (geschwindigkeit < 0) + { + geschwindigkeit = 0; + } + _verzoegerung = 10 - geschwindigkeit; + } + + /** + * Gibt die X-Position der Turtle zurueck. + * @return die X-Position + */ + public double gibX() + { + return _xPos; + } + + /** + * Gibt die Y-Position der Turtle zurueck. + * @return die Y-Position + */ + public double gibY() + { + return _yPos; + } + + /** + * Gibt die Richtung der Turtle zurueck. + * @return die Richtung + */ + public double gibRichtung() + { + return _richtung; + } + + /** + * Abhaengig von der Geschwindigkeit dieser Turtle wird hier kurze Zeit verzoegert. + */ + private void verzoegern() + { + if (_verzoegerung > 0) + { + try + { + Thread.sleep(_verzoegerung); + } + catch (InterruptedException ignore) + { + //tue nichts + } + } + } +} + +/** + * Eine Welt, in der sich Turtles bewegen. + * + * @author Original von Alfred Hermes (14.12.2003) + * @author Simon Gerlach + * @author Axel Schmolitzky + * @author Fredrik Winkler + * @version 5. Dezember 2018 + */ +class TurtleWelt +{ + public static final int WIDTH = 500; + public static final int HEIGHT = 500; + + public static final TurtleWelt GLOBALEWELT = new TurtleWelt(); + + private final Graphics2D _graphics; + private final JFrame _frame; + + /** + * Initialisiert eine neue TurtleWelt. + */ + public TurtleWelt() + { + BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB); + + _graphics = image.createGraphics(); + _graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + _graphics.setColor(Color.WHITE); + _graphics.fillRect(0, 0, WIDTH, HEIGHT); + + JPanel panel = new ImagePanel(image); + panel.addMouseListener(new MouseAdapter() + { + public void mousePressed(MouseEvent e) + { + if (e.getButton() != MouseEvent.BUTTON1) + { + loescheAlleSpuren(); + } + } + }); + + _frame = new JFrame("Turtle Graphics - the canvas can be cleared by right-clicking on it"); + _frame.add(panel); + _frame.pack(); + _frame.setResizable(false); + _frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + _frame.setVisible(true); + } + + /** + * Loescht alle Spuren, die Turtles bisher hinterlassen haben. + */ + public void loescheAlleSpuren() + { + _graphics.setColor(new Color(16, 68, 116)); + _graphics.fillRect(0, 0, WIDTH, HEIGHT); + _frame.repaint(); + } + + /** + * Faerbt den Frame in einer bestimmten Farbe mit RGB Wert. + * + * @param r der Rotanteil + * @param g der Gruenanteil + * @param b der Blauanteil + */ + public void bildschirmEinfaerben(int r, int g, int b) + { + //Absicherung gegen unzulaessige Werte + r = r % 256; + g = g % 256; + b = b % 256; + + _graphics.setColor(new Color(r, g, b)); + _graphics.fillRect(0, 0, WIDTH, HEIGHT); + _frame.repaint(); + } + + /** + * Zeichnet eine farbige Linie von (x1/y1) nach (x2/y2). + * + * @param x1 x-Wert vom ersten Koordinatenpaar + * @param y1 y-Wert vom ersten Koordinatenpaar + * @param x2 x-Wert vom zweiten Koordinatenpaar + * @param y2 y-Wert vom ersten Koordinatenpaar + * @param farbe gewuenschte Farbe fuer die Linie + */ + public void zeichneLinie(double x1, double y1, double x2, double y2, Color farbe) + { + _graphics.setColor(farbe); + _graphics.drawLine((int) (x1 + 0.5), (int) (y1 + 0.5), (int) (x2 + 0.5), (int) (y2 + 0.5)); + _frame.repaint(); + } +} + +/** + * Ein Panel, das lediglich aus einem Bild besteht. + * + * @author Original von Alfred Hermes (14.12.2003) + * @author Simon Gerlach + * @author Axel Schmolitzky + * @author Fredrik Winkler + * @version 5. Dezember 2018 + */ +class ImagePanel extends JPanel +{ + private final BufferedImage _image; + + /** + * Initialisiert ein neues ImagePanel mit dem angegebenen Bild. + * + * @param image das Bild fuer das ein ImagePanel angelegt werden soll + */ + public ImagePanel(BufferedImage image) + { + super(null); + _image = image; + setPreferredSize(new Dimension(_image.getWidth(), _image.getHeight())); + } + + /** + * Zeichnet das ImagePanel. + * + * @param g das Graphicsobjekt fuer das Bild + */ + public void paintComponent(Graphics g) + { + g.drawImage(_image, 0, 0, null); + } +} diff --git a/bluej.pkg b/bluej.pkg new file mode 100644 index 0000000..1cdb4c6 --- /dev/null +++ b/bluej.pkg @@ -0,0 +1,44 @@ +#BlueJ package file +dependency1.from=Dompteur +dependency1.to=Turtle +dependency1.type=UsesDependency +editor.fx.0.height=722 +editor.fx.0.width=800 +editor.fx.0.x=790 +editor.fx.0.y=102 +objectbench.height=102 +objectbench.width=461 +package.divider.horizontal=0.6 +package.divider.vertical=0.7966417910447762 +package.editor.height=420 +package.editor.width=661 +package.editor.x=704 +package.editor.y=449 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=1 +package.numTargets=2 +package.showExtends=true +package.showUses=true +project.charset=windows-1252 +readme.height=60 +readme.name=@README +readme.width=48 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Turtle +target1.naviview.expanded=true +target1.showInterface=false +target1.type=ClassTarget +target1.width=80 +target1.x=170 +target1.y=120 +target2.height=50 +target2.name=Dompteur +target2.naviview.expanded=true +target2.showInterface=false +target2.type=ClassTarget +target2.width=90 +target2.x=70 +target2.y=40 diff --git a/package.bluej b/package.bluej new file mode 100644 index 0000000..1cdb4c6 --- /dev/null +++ b/package.bluej @@ -0,0 +1,44 @@ +#BlueJ package file +dependency1.from=Dompteur +dependency1.to=Turtle +dependency1.type=UsesDependency +editor.fx.0.height=722 +editor.fx.0.width=800 +editor.fx.0.x=790 +editor.fx.0.y=102 +objectbench.height=102 +objectbench.width=461 +package.divider.horizontal=0.6 +package.divider.vertical=0.7966417910447762 +package.editor.height=420 +package.editor.width=661 +package.editor.x=704 +package.editor.y=449 +package.frame.height=600 +package.frame.width=800 +package.numDependencies=1 +package.numTargets=2 +package.showExtends=true +package.showUses=true +project.charset=windows-1252 +readme.height=60 +readme.name=@README +readme.width=48 +readme.x=10 +readme.y=10 +target1.height=50 +target1.name=Turtle +target1.naviview.expanded=true +target1.showInterface=false +target1.type=ClassTarget +target1.width=80 +target1.x=170 +target1.y=120 +target2.height=50 +target2.name=Dompteur +target2.naviview.expanded=true +target2.showInterface=false +target2.type=ClassTarget +target2.width=90 +target2.x=70 +target2.y=40 -- GitLab