- * Farben bestehen entweder aus einem Grauwert (zwischen 0 und - * 255) oder einem Rot-, Grün- und Blauanteil (jeweils zwischen - * 0 und 255). + * Farben bestehen entweder aus einem Grauwert (zwischen 0 und 255) oder einem + * Rot-, Grün- und Blauanteil (jeweils zwischen 0 und 255). *
- * Eine Farbe hat außerdem einen Transparenzwert zwischen 0 - * (unsichtbar) und 255 (deckend). + * Eine Farbe hat außerdem einen Transparenzwert zwischen 0 (unsichtbar) und 255 + * (deckend). */ public class Color { - //@formatter:off /** * Die Farbe Schwarz (Grauwert 0). @@ -124,12 +122,12 @@ public class Color { /** * Erstellt eine Farbe. Die Parameter red, green und - * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte - * liegen zwischen 0 und 255. + * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die + * Werte liegen zwischen 0 und 255. * - * @param red Rotwert zwischen 0 und 255. + * @param red Rotwert zwischen 0 und 255. * @param green Grünwert zwischen 0 und 255. - * @param blue Blauwert zwischen 0 und 255. + * @param blue Blauwert zwischen 0 und 255. */ public Color( int red, int green, int blue ) { this(red, green, blue, 255); @@ -137,20 +135,18 @@ public class Color { /** * Erstellt eine Farbe. Die Parameter red, green und - * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte - * liegen zwischen 0 und 255. + * blue geben die Rot-, Grün- und Blauanteile der Farbe. Die + * Werte liegen zwischen 0 und 255. * alpha gibt den den Transparentwert an (auch zwischen - * 0 und 255), wobei - * 0 komplett durchsichtig ist und 255 komplett - * deckend. + * 0 und 255), wobei 0 komplett durchsichtig ist und 255 komplett deckend. * - * @param red Rotwert zwischen 0 und 255. + * @param red Rotwert zwischen 0 und 255. * @param green Grünwert zwischen 0 und 255. - * @param blue Blauwert zwischen 0 und 255. + * @param blue Blauwert zwischen 0 und 255. * @param alpha Transparentwert zwischen 0 und 255. */ public Color( int red, int green, int blue, int alpha ) { - rgba = (alpha << 24) | (red << 16) | (green << 8) | blue; + rgba = ((alpha&0xFF) << 24) | ((red&0xFF) << 16) | ((green&0xFF) << 8) | ((blue&0xFF) << 0); } /** @@ -184,10 +180,11 @@ public class Color { /** * Interner Konstruktor für die Initialisierung einer Farbe mit einem * RGBA-Wert. - * + *
* Da der Konstruktor {@link #Color(int)} schon besetzt ist, muss hier der - * Parameter {@code isRGBA} auf {@code true} gesetzt werden, damit {@code rgba} - * korrekt interpretiert wird. + * Parameter {@code isRGBA} auf {@code true} gesetzt werden, damit + * {@code rgba} korrekt interpretiert wird. + * * @param rgba RGBA-wert der Farbe. * @param isRGBA Sollte immer {@code true} sein. */ @@ -210,12 +207,12 @@ public class Color { return c; } - public static Color getHSBColor(double h, double s, double b) { - return new Color(java.awt.Color.getHSBColor((float)h, (float)s, (float)b)); + public static Color getHSBColor( double h, double s, double b ) { + return new Color(java.awt.Color.getHSBColor((float) h, (float) s, (float) b)); } - public static Color getHSLColor(double h, double s, double l) { - int rgb = Color.HSLtoRGB(new float[]{(float)h, (float)s, (float)l}); + public static Color getHSLColor( double h, double s, double l ) { + int rgb = Color.HSLtoRGB(new float[]{(float) h, (float) s, (float) l}); return Color.getRGBColor(rgb); } @@ -235,9 +232,9 @@ public class Color { } /** - * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann - * sechs- oder achtstellig sein (wenn ein Transparentwert vorhanden ist). - * Dem Code kann ein {@code #} Zeichen vorangestellt sein. + * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann sechs- + * oder achtstellig sein (wenn ein Transparentwert vorhanden ist). Dem Code + * kann ein {@code #} Zeichen vorangestellt sein. * * @param hexcode * @return @@ -336,10 +333,11 @@ public class Color { /** * Konvertiert eine Farbe mit Komponenten im HSL-Farbraum in den * RGB-Farbraum. - * + *
* Die Farbkomponenten werden als Float-Array übergeben. Im Index 0 steht * der h-Wert im Bereich 0 bis 360, Index 1 und 2 enthalten den s- und * l-Wert im Bereich von 0 bis 1. + * * @param hsl Die Farbkomponenten im HSL-Farbraum. * @param alpha Ein Transparenzwert im Bereich 0 bis 255. * @return Der RGBA-Wert der Farbe. @@ -392,6 +390,7 @@ public class Color { /** * Erzeugt eine Kopie dieser Farbe. + * * @return Ein neues Farbobjekt. */ public Color copy() { @@ -400,10 +399,11 @@ public class Color { /** * Gibt den RGBA-Wert dieser Farbe zurück. - * - * Eine Farbe wird als 32-Bit Integer gespeichert. Bits 24-31 enthalten - * den Transparenzwert, 16-23 den Rotwert, 8-15 den Grünwert und 0-7 den + *
+ * Eine Farbe wird als 32-Bit Integer gespeichert. Bits 24-31 enthalten den + * Transparenzwert, 16-23 den Rotwert, 8-15 den Grünwert und 0-7 den * Blauwert der Farbe. + * * @return Der RGBA-Wert der Farbe. * @see #getRed() * @see #getGreen() @@ -416,6 +416,7 @@ public class Color { /** * Gibt den Rotwert dieser Farbe zurück. + * * @return Der Rotwert der Farbe zwischen 0 und 255. */ public int getRed() { @@ -424,6 +425,7 @@ public class Color { /** * Gibt den Grünwert dieser Farbe zurück. + * * @return Der Grünwert der Farbe zwischen 0 und 255. */ public int getGreen() { @@ -432,6 +434,7 @@ public class Color { /** * Gibt den Blauwert dieser Farbe zurück. + * * @return Der Blauwert der Farbe zwischen 0 und 255. */ public int getBlue() { @@ -440,6 +443,7 @@ public class Color { /** * Gibt den Transparenzwert dieser Farbe zurück. + * * @return Der Transparenzwert der Farbe zwischen 0 und 255. */ public int getAlpha() { @@ -448,9 +452,10 @@ public class Color { /** * Erzeugt ein {@link java.awt.Color}-Objekt aus dieser Farbe. + *
+ * Das erzeugte Farbobjekt hat dieselben Rot-, Grün-, Blau- und + * Transparenzwerte wie diese Farbe. * - * Das erzeugte Farbobjekt hat dieselben Rot-, Grün-, Blau- - * und Transparenzwerte wie diese Farbe. * @return Ein Java-Farbobjekt. */ public java.awt.Color getJavaColor() { @@ -468,11 +473,18 @@ public class Color { * @return {@code true}, wenn die Objekte gleich sind, sonst {@code false}. */ public boolean equals( Object obj ) { - return obj instanceof Color && ((Color)obj).getRGBA() == this.rgba; + if( obj == null ) { return false; } + if( obj instanceof Color ) { + return ((Color) obj).getRGBA() == this.rgba; + } else if( obj instanceof java.awt.Color ) { + return ((java.awt.Color) obj).getRGB() == this.rgba; + } + return false; } /** * Erzeugt einen Text-String, der diese Farbe beschreibt. + * * @return Eine Textversion der Farbe. */ @Override @@ -482,6 +494,7 @@ public class Color { /** * Berechnet einen Hashcode für dieses Farbobjekt. + * * @return Ein Hashcode für diese Rabe. */ @Override @@ -490,7 +503,8 @@ public class Color { } /** - * Erzeugt eine um 30% hellere Version dieser Farbe. + * Erzeugt eine um 30% hellere Version dieser Farbe. + * * @return Ein Farbobjekt mit einer helleren Farbe. */ public Color brighter() { @@ -499,6 +513,7 @@ public class Color { /** * Erzeugt eine um {@code percent} hellere Version dieser Farbe. + * * @param percent Eine Prozentzahl zwischen 0 und 100. * @return Ein Farbobjekt mit einer helleren Farbe. */ @@ -510,6 +525,7 @@ public class Color { /** * Erzeugt eine um 30% dunklere Version dieser Farbe. + * * @return Ein Farbobjekt mit einer dunkleren Farbe. */ public Color darker() { @@ -518,6 +534,7 @@ public class Color { /** * Erzeugt eine um {@code percent} dunklere Version dieser Farbe. + * * @param percent Eine Prozentzahl zwischen 0 und 100. * @return Ein Farbobjekt mit einer dunkleren Farbe. */ @@ -528,11 +545,12 @@ public class Color { } public Color greyscale() { - return new Color((int)(getRed()*.299 + getGreen()*.587 + getBlue()*0.114)); + return new Color((int) (getRed() * .299 + getGreen() * .587 + getBlue() * 0.114)); } /** * Erzeugt eine zu dieser invertierte Farbe. + * * @return Ein Farbobjekt mit der invertierten Farbe. */ public Color inverted() { @@ -542,6 +560,7 @@ public class Color { /** * Erzeugt die Komplementärfarbe zu dieser. + * * @return Ein Farbobjekt mit der Komplementärfarbe. */ public Color complement() { @@ -554,11 +573,12 @@ public class Color { * Wählt entweder {@link #WHITE weiß} oder {@link #BLACK schwarz} aus, je * nachdem, welche der Farben besser als Textfarbe mit dieser Farbe als * Hintergrund funktioniert (besser lesbar ist). + * * @return Schwarz oder weiß. */ public Color textcolor() { // Basiert auf https://stackoverflow.com/questions/946544/good-text-foreground-color-for-a-given-background-color - if( (getRed()*.299 + getGreen()*.587 + getBlue()*0.114) < 186 ) { + if( (getRed() * .299 + getGreen() * .587 + getBlue() * 0.114) < 186 ) { return WHITE; } else { return BLACK; diff --git a/src/main/java/schule/ngb/zm/Constants.java b/src/main/java/schule/ngb/zm/Constants.java index 561b3aa..b9436f0 100644 --- a/src/main/java/schule/ngb/zm/Constants.java +++ b/src/main/java/schule/ngb/zm/Constants.java @@ -1,6 +1,7 @@ package schule.ngb.zm; import schule.ngb.zm.util.ImageLoader; +import schule.ngb.zm.util.Noise; import java.awt.Cursor; import java.awt.event.KeyEvent; @@ -8,6 +9,39 @@ import java.awt.event.MouseEvent; import java.awt.image.BufferedImage; import java.util.Random; +/** + * Basisklasse für die meisten Objekte der Zeichemaschine, die von Nutzern + * erweitert werden können. + *
+ * Die Konstanten stellen viele Funktionen zur einfachen Programmierung bereit + * und enthält auch einige dynamische Werte, die von der Zeichenmaschine laufend + * aktuell gehalten werden (beispielsweise {@link #runtime}. + *
+ * Für die Implementierung eigener Klassen ist es oft hilfreich von
+ * {@code Constants} zu erben, um die Methoden und Konstanten einfach im
+ * Programm nutzen zu können.
+ *
+ * class MyClass extends Constants {
+ * public int summe( int a, int b ) {
+ * // sum ist durch Vererbung verfügbar,
+ * return sum(a, b);
+ * }
+ * }
+ *
+ * Alternativ können die statischen Klassenmethoden auch direkt genutzt werden:
+ *
+ * Constants.sum(1,2,3,4); // 10
+ *
+ * Oder die Methoden statisch importiert werden:
+ *
+ * import static Constants.*;
+ *
+ * sum(1, 2, 3, 4); // 10
+ *
+ * Color iron_grey = color(94);
+ *
+ * Color iron_grey_50 = color(94, 50);
+ *
+ * Color arctic_blue = color(149, 214, 220);
+ *
+ * Color arctic_blue_50 = color(149, 214, 220, 50);
+ *
+ * Color fillColor = randomColor();
+ *
+ * Color fillColor = randomNiceColor();
+ *
+ * Color arctic_blue = colorHsl(185, 32, 86);
+ *
+ * Color arctic_blue = colorHsl(185, 50, 72);
+ *
+ * double minimum = min(1.0, 5.1, 3.2); // 1.0
+ *
+ * double maximum = max(1.0, 5.1, 3.2); // 5.1
+ *
+ * double summe = sum(1.0, 2.0, 3.2); // 6.2
+ *
+ * double summe = sum(1.0, 2.2, 3.1); // 2.1
+ *
+ * double positiv = abs(-3.2); // 3.2
+ *
+ * double vorzeichen = sign(-3.2); // -1.0
+ *
+ * double gerundet = sign(3.2); // 3.0
+ *
+ * double abgerundet = sign(3.2); // 3.0
+ *
+ * double aufgerundet = sign(3.2); // 4.0
+ *
+ * double wurzel = sqrt(16); // 4.0
+ *
+ * double hoch4 = sqrt(8, 4); // 4096.0
+ *
+ * double radian = radians(360); // 6.28318530717959
+ *
+ * double grad = radians(HALF_PI); // 90.0
+ *
+ * double sinus = sin(0.0); // 0.0
+ *
+ * double kosinus = cos(0.0); // 1.0
+ *
+ * double sinus = tan(1.0); // 1.5574077246549
+ *
+ * double beschraenkt1 = limit(2.1, 0.0, 3.0); // 2.1
+ * double beschraenkt2 = limit(4.1, 0.0, 3.0); // 1.0
+ *
+ * double beschraenkt1 = limit(2, 0, 3); // 2
+ * double beschraenkt2 = limit(4, 0, 3); // 3
+ * * from - t * (from + to) *+ *
+ * In der Regel liegt {@code t} im Intervall {@code [0, 1]}. Für + * {@code t = 0} ist das Ergebnis {@code from} und für {@code t = 1} ist das + * Ergebnis {@code to}. {@code t} kann aber auch Werte außerhalb des + * Intervalls annehmen. Für {@code t = 2} ist das Ergebnis beispielsweise + * {@code 2*to}; + * + *
+ * double interpoliert = interpolate(100.0, 500.0, 0.5); // 300.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.0); // 500.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.5); // 750.0
+ *
+ * double interpoliert = interpolate(100.0, 500.0, 0.5); // 300.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.0); // 500.0
+ * double interpoliert = interpolate(100.0, 500.0, 1.5); // 500.0
+ * + * Für {@code value = fromMin} wird {@code toMin} zurückgegeben. Für + * {@code value = fromMax} ist das Ergebnis {@code toMax}. Befindet sich + * {@code value} genau mittig zwischen {@code fromMin} und {@code fromMax}, + * dann ist das Ergebnis genau {@code interpolate(toMin, toMax, 0.5)}. + *
+ * Mit {@code map()} lassen sich Werte eines Originalintervalls auf ein + * Zielintervalls transponieren. Dies ist beispielsweise hilfreich, um aus + * der Mausbewegung die relative Position auf der Zeichenfläche zu + * bestimmen: + * + *
+ * double relativeMouseX = map(mouseX, 0.0, canvasWidth, 0.0, 1.0);
+ *
+ * int bin = binary(10); // "1010"
+ *
+ * int dezimal = romBinary("1010"); // 10
+ *
+ * int hexa = hex(255); // "FF"
+ *
+ * int dezimal = romHex("FF"); // 255
+ * true, wenn das Objekt sichtbar ist.
+ * @return {@code true}, wenn das Objekt sichtbar ist.
*/
boolean isVisible();
diff --git a/src/main/java/schule/ngb/zm/DrawingLayer.java b/src/main/java/schule/ngb/zm/DrawingLayer.java
index 4694527..4289aaf 100644
--- a/src/main/java/schule/ngb/zm/DrawingLayer.java
+++ b/src/main/java/schule/ngb/zm/DrawingLayer.java
@@ -191,7 +191,8 @@ public class DrawingLayer extends Layer {
}
public void pixel( double x, double y ) {
- square(x, y, 1);
+ // square(x, y, 1);
+ buffer.setRGB((int)x, (int)y, fillColor.getRGBA());
}
public void square( double x, double y, double w ) {
diff --git a/src/main/java/schule/ngb/zm/Options.java b/src/main/java/schule/ngb/zm/Options.java
index 70cf071..d903367 100644
--- a/src/main/java/schule/ngb/zm/Options.java
+++ b/src/main/java/schule/ngb/zm/Options.java
@@ -42,6 +42,7 @@ public final class Options {
public enum Direction {
CENTER(0, 0),
+
NORTH(0, -1),
EAST(1, 0),
SOUTH(0, 1),
@@ -49,14 +50,19 @@ public final class Options {
NORTHEAST(1, -1),
SOUTHEAST(1, 1),
- NORTHWEST(-1, -1),
SOUTHWEST(-1, 1),
+ NORTHWEST(-1, -1),
MIDDLE(CENTER),
UP(NORTH),
+ RIGHT(EAST),
DOWN(SOUTH),
LEFT(WEST),
- RIGHT(EAST);
+
+ UPLEFT(NORTHWEST),
+ DOWNLEFT(SOUTHWEST),
+ DOWNRIGHT(SOUTHEAST),
+ UPRIGHT(NORTHEAST);
public final byte x, y;
diff --git a/src/main/java/schule/ngb/zm/Updatable.java b/src/main/java/schule/ngb/zm/Updatable.java
index 0a60447..0998e1c 100644
--- a/src/main/java/schule/ngb/zm/Updatable.java
+++ b/src/main/java/schule/ngb/zm/Updatable.java
@@ -9,7 +9,7 @@ public interface Updatable {
/**
* Gibt an, ob das Objekt gerade auf Aktualisierungen reagiert.
- * @return true, wenn das Objekt aktiv ist.
+ * @return {@code true}, wenn das Objekt aktiv ist.
*/
public boolean isActive();
diff --git a/src/main/java/schule/ngb/zm/Zeichenleinwand.java b/src/main/java/schule/ngb/zm/Zeichenleinwand.java
index 73b9bae..d59fdaf 100644
--- a/src/main/java/schule/ngb/zm/Zeichenleinwand.java
+++ b/src/main/java/schule/ngb/zm/Zeichenleinwand.java
@@ -1,7 +1,5 @@
package schule.ngb.zm;
-import schule.ngb.zm.shapes.ShapesLayer;
-
import java.awt.Canvas;
import java.awt.Graphics;
import java.awt.Graphics2D;
@@ -37,12 +35,12 @@ public class Zeichenleinwand extends Canvas {
super.setSize(width, height);
this.setPreferredSize(this.getSize());
this.setMinimumSize(this.getSize());
- this.setBackground(Constants.STD_BACKGROUND.getJavaColor());
+ this.setBackground(Constants.DEFAULT_BACKGROUND.getJavaColor());
// Liste der Ebenen initialisieren und die Standardebenen einfügen
layers = new LinkedList<>();
synchronized( layers ) {
- layers.add(new ColorLayer(width, height, Constants.STD_BACKGROUND));
+ layers.add(new ColorLayer(width, height, Constants.DEFAULT_BACKGROUND));
}
}
@@ -90,7 +88,7 @@ public class Zeichenleinwand extends Canvas {
* als letzte eingefügt. Die aufrufende Methode kann also nicht sicher sein,
* dass die neue Ebene am Ende wirklich am Index {@code i} steht.
*
- * @param i Index der Ebene, beginnend mit 0.
+ * @param i Index der Ebene, beginnend mit 0.
* @param layer Die neue Ebene.
*/
public void addLayer( int i, Layer layer ) {
@@ -125,10 +123,10 @@ public class Zeichenleinwand extends Canvas {
}
/**
- * Holt die Ebene am Index i (beginnend bei 0).
+ * Holt die Ebene am Index i (beginnend bei 0).
*
- * @param i Index der Ebene (beginnend bei 0).
- * @return Die Ebene am Index i oder null.
+ * @param i Index der Ebene (beginnend bei 0).
+ * @return Die Ebene am Index i oder {@code null}.
* @throws IndexOutOfBoundsException Falls der Index nicht existiert.
*/
public Layer getLayer( int i ) {
@@ -141,7 +139,7 @@ public class Zeichenleinwand extends Canvas {
/**
* Sucht die erste Ebene des angegebenen Typs aus der Liste der Ebenen.
- * Existiert keine solche Ebene, wird null zurückgegeben.
+ * Existiert keine solche Ebene, wird {@code null} zurückgegeben.
*
* @param clazz Typ der Ebene.
* @param + * Die Lautstärke wird auf einer linearen Skale angegeben, wobei 0 kein Ton + * und 1 volle Lautstärke bedeutet. Werte über 1 verstärken den Ton des + * Mediums. + * + * @return Die Lautstärke als linear skalierter Wert. + */ + double getVolume(); + /** * Startet die Wiedergabe des Mediums und beendet die Methode. Das * Audio-Medium wird einmal abgespielt und stoppt dann. */ - void playOnce(); + void play(); /** * Startet die Wiedergabe des Mediums und blockiert das Programm, bis die * Wiedergabe beendet ist. */ - void playOnceAndWait(); + void playAndWait(); /** * Spielt das Medium in einer kontinuierlichen Schleife ab. Die Methode diff --git a/src/main/java/schule/ngb/zm/media/Mixer.java b/src/main/java/schule/ngb/zm/media/Mixer.java index 91b2064..f94ec4f 100644 --- a/src/main/java/schule/ngb/zm/media/Mixer.java +++ b/src/main/java/schule/ngb/zm/media/Mixer.java @@ -50,30 +50,53 @@ public class Mixer implements Audio { pAudio.setVolume(pVolumeFactor * volume); } + /** + * {@inheritDoc} + */ @Override public boolean isPlaying() { return audios.stream().anyMatch(aw -> aw.audio.isPlaying()); } + /** + * {@inheritDoc} + */ @Override public boolean isLooping() { return audios.stream().anyMatch(aw -> aw.audio.isLooping()); } + /** + * {@inheritDoc} + */ @Override public void setVolume( double pVolume ) { volume = (float) pVolume; audios.stream().forEach(aw -> aw.audio.setVolume(aw.volumeFactor * pVolume)); } + /** + * {@inheritDoc} + */ @Override - public void playOnce() { - audios.stream().forEach(aw -> aw.audio.playOnce()); + public double getVolume() { + return volume; } + /** + * {@inheritDoc} + */ @Override - public void playOnceAndWait() { - audios.stream().forEach(aw -> aw.audio.playOnce()); + public void play() { + audios.stream().forEach(aw -> aw.audio.play()); + } + + /** + * {@inheritDoc} + */ + @Override + public void playAndWait() { + audios.stream().forEach(aw -> aw.audio.play()); while( audios.stream().anyMatch(aw -> aw.audio.isPlaying()) ) { try { Thread.sleep(10); @@ -83,16 +106,25 @@ public class Mixer implements Audio { } } + /** + * {@inheritDoc} + */ @Override public void loop() { audios.stream().forEach(aw -> aw.audio.loop()); } + /** + * {@inheritDoc} + */ @Override public void stop() { audios.stream().forEach(aw -> aw.audio.stop()); } + /** + * {@inheritDoc} + */ @Override public void dispose() { if( isPlaying() ) { @@ -101,6 +133,18 @@ public class Mixer implements Audio { audios.stream().forEach(aw -> aw.audio.dispose()); } + /** + * Ändert die Lautstärke aller hinzugefügten Audiomedien in der angegebenen + * Zeit schrittweise, bis die angegebene Lautstärke erreicht ist. + *
+ * Zu beachten ist, dass die Lautstärke des Mixers angepasst wird. Das + * bedeutet, dass die Lautstärke der hinzugefügten Medien mit ihrem + * Lautstärkefaktor multipliziert werden. Die Medien haben am Ende also + * nicht unbedingt die Lautstärke {@code to}. + * + * @param to Der Zielwert für die Lautstärke. + * @param time Die Zeit, nach der die Änderung abgeschlossen sein soll. + */ public void fade( final double to, final int time ) { TaskRunner.run(new Runnable() { @Override @@ -108,9 +152,6 @@ public class Mixer implements Audio { final long start = System.currentTimeMillis(); double t = 0.0; double from = volume; - if( !isPlaying() ) { - playOnce(); - } do { setVolume(Constants.interpolate(from, to, t)); t = (double) (System.currentTimeMillis() - start) / (double) time; diff --git a/src/main/java/schule/ngb/zm/media/Music.java b/src/main/java/schule/ngb/zm/media/Music.java index fa03cf3..72ad34c 100644 --- a/src/main/java/schule/ngb/zm/media/Music.java +++ b/src/main/java/schule/ngb/zm/media/Music.java @@ -1,43 +1,82 @@ package schule.ngb.zm.media; import schule.ngb.zm.tasks.TaskRunner; +import schule.ngb.zm.util.Log; import schule.ngb.zm.util.ResourceStreamProvider; +import schule.ngb.zm.util.Validator; import javax.sound.sampled.*; -import java.io.BufferedInputStream; import java.io.IOException; -import java.io.InputStream; import java.net.URL; -import java.util.logging.Level; -import java.util.logging.Logger; +/** + * Ein Musikstück, dass im Projekt abgespielt werden soll. + *
+ * Im gegensatz zu einem {@link Sound} sind Musikstücke längere Audiodateien, + * die zum Beispiel als Hintergrundmusik ablaufen sollen. Die Musik wird daher + * nicht komplett in den Speicher geladen, sondern direkt aus der Audioquelle + * gestreamt und wiedergegeben. + */ public class Music implements Audio { // size of the byte buffer used to read/write the audio stream private static final int BUFFER_SIZE = 4096; + /** + * Ob der Sound gerade abgespielt wird. + */ private boolean playing = false; + /** + * Ob der Sound gerade in einer Schleife abgespielt wird. + */ private boolean looping = false; + /** + * Die Quelle des Musikstücks. + */ private String audioSource; + /** + * Der AudioStream, um die AUdiosdaten zulsen, falls dieser schon geöffnet + * wurde. Sonst {@code null}. + */ private AudioInputStream audioStream; + /** + * Die Line für die Ausgabe, falls diese schon geöffnet wurde. Sonst + * {@code null}. + */ private SourceDataLine audioLine; + /** + * Die Lautstärke der Musik. + */ private float volume = 0.8f; + /** + * Erstellt eine Musik aus der angegebenen Datei oder Webadresse. + * + * @param source Ein Dateipfad oder eine Webadresse. + * @throws NullPointerException Falls die Quelle {@code null} ist. + */ public Music( String source ) { + Validator.requireNotNull(source); this.audioSource = source; } + /** + * {@inheritDoc} + */ @Override public boolean isPlaying() { return playing; } + /** + * {@inheritDoc} + */ @Override public boolean isLooping() { if( !playing ) { @@ -46,6 +85,9 @@ public class Music implements Audio { return looping; } + /** + * {@inheritDoc} + */ @Override public void setVolume( double volume ) { this.volume = (float) volume; @@ -54,6 +96,18 @@ public class Music implements Audio { } } + /** + * {@inheritDoc} + */ + @Override + public double getVolume() { + return volume; + } + + /** + * Interne Methode, um die gesetzte Lautstärke vor dem Abspielen + * anzuwenden. + */ private void applyVolume() { FloatControl gainControl = (FloatControl) audioLine.getControl(FloatControl.Type.MASTER_GAIN); @@ -63,8 +117,11 @@ public class Music implements Audio { gainControl.setValue(vol); } + /** + * {@inheritDoc} + */ @Override - public void playOnce() { + public void play() { if( openLine() ) { TaskRunner.run(new Runnable() { @Override @@ -75,19 +132,28 @@ public class Music implements Audio { } } + /** + * {@inheritDoc} + */ @Override - public void playOnceAndWait() { + public void playAndWait() { if( openLine() ) { stream(); } } + /** + * {@inheritDoc} + */ @Override public void loop() { looping = true; - playOnce(); + play(); } + /** + * {@inheritDoc} + */ @Override public void stop() { playing = false; @@ -95,6 +161,9 @@ public class Music implements Audio { dispose(); } + /** + * {@inheritDoc} + */ @Override public void dispose() { if( audioLine != null ) { @@ -112,7 +181,8 @@ public class Music implements Audio { if( audioStream != null ) { audioStream.close(); } - } catch( IOException ex ) {} + } catch( IOException ex ) { + } audioLine = null; audioStream = null; @@ -126,15 +196,14 @@ public class Music implements Audio { int bytesRead = -1; try { - while (playing && (bytesRead = audioStream.read(bytesBuffer)) != -1) { + while( playing && (bytesRead = audioStream.read(bytesBuffer)) != -1 ) { audioLine.write(bytesBuffer, 0, bytesRead); } audioLine.drain(); audioLine.stop(); } catch( IOException ex ) { - LOGGER.warning("Error while playing Music source <" + audioSource + ">"); - LOGGER.throwing("Music", "stream", ex); + LOG.warn(ex, "Error while playing Music source <%s>", audioSource); } // Wait for the remaining audio to play @@ -163,7 +232,7 @@ public class Music implements Audio { final int ch = format.getChannels(); final float rate = format.getSampleRate(); - AudioFormat outFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, rate, 16, ch, ch*2, rate, false); + AudioFormat outFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, rate, 16, ch, ch * 2, rate, false); DataLine.Info info = new DataLine.Info(SourceDataLine.class, outFormat); @@ -174,14 +243,14 @@ public class Music implements Audio { audioStream = AudioSystem.getAudioInputStream(outFormat, inStream); return true; } else { - LOGGER.warning("Sound source <" + audioSource + "> could not be played: No audio source found."); + LOG.warn("Sound source <%s> could not be played: No audio source found.", audioSource); } } catch( UnsupportedAudioFileException ex ) { - LOGGER.log(Level.WARNING, "Sound source <" + audioSource + "> could not be played: The specified audio file is not supported.", ex); + LOG.warn(ex, "Sound source <%s> could not be played: The specified audio file is not supported.", audioSource); } catch( LineUnavailableException ex ) { - LOGGER.log(Level.WARNING, "Sound source <" + audioSource + "> could not be played: Audio line for playing back is unavailable.", ex); + LOG.warn(ex, "Sound source <%s> could not be played: Audio line for playing back is unavailable.", audioSource); } catch( IOException ex ) { - LOGGER.log(Level.WARNING, "Sound source <" + audioSource + "> could not be played: Error playing the audio file.", ex); + LOG.warn(ex, "Sound source <%s> could not be played: Error playing the audio file.", audioSource); } return false; } @@ -201,7 +270,6 @@ public class Music implements Audio { } } - //private static final Logger LOGGER = Logger.getLogger("schule.ngb.zm.media.Music"); - private static final Logger LOGGER = Logger.getLogger(Music.class.getName()); + private static final Log LOG = Log.getLogger(Music.class); } diff --git a/src/main/java/schule/ngb/zm/media/Sound.java b/src/main/java/schule/ngb/zm/media/Sound.java index ceda917..ece650d 100644 --- a/src/main/java/schule/ngb/zm/media/Sound.java +++ b/src/main/java/schule/ngb/zm/media/Sound.java @@ -1,35 +1,84 @@ package schule.ngb.zm.media; +import schule.ngb.zm.util.Log; import schule.ngb.zm.util.ResourceStreamProvider; +import schule.ngb.zm.util.Validator; import javax.sound.sampled.*; import java.io.IOException; import java.io.InputStream; import java.util.logging.Logger; +/** + * Wiedergabe kurzer Soundclips, die mehrmals wiederverwendet werden. + *
+ * In Spielen und anderen Projekten gibt es oftmals eine Reihe kurzer Sounds, + * die zusammen mit bestimmten Aktionen wiedergegeben werden (zum Beispiel, wenn + * die Spielfigur springt, wenn zwei Objekte kollidieren, usw.). Sounds werden + * komplett in den Speicher geladen und können dadurch immer wieder, als + * Schleife oder auch nur Abschnittsweise abgespielt werden. + *
+ * Für längre Musikstücke (beispielsweise Hintergrundmusik) bietet sich eher die + * KLasse {@link Music} an. + */ +@SuppressWarnings( "unused" ) public class Sound implements Audio { + /** + * Ob der Sound gerade abgespielt wird. + */ private boolean playing = false; + /** + * Ob der Sound gerade in einer Schleife abgespielt wird. + */ private boolean looping = false; + /** + * Die Quelle des Musikstücks. + */ private String audioSource; + /** + * Der Clip, falls er schon geladen wurde, sonst {@code null}. + */ private Clip audioClip; + /** + * Ob die Resourcen des Clips im Speicher nach dem nächsten Abspielen + * freigegeben werden sollen. + */ private boolean disposeAfterPlay = false; + /** + * Die Lautstärke des Clips. + */ private float volume = 0.8f; + /** + * Erstellt einen Sound aus der angegebene Quelle. + * + * @param source Ein Dateipfad oder eine Webadresse. + * @throws NullPointerException Falls die Quelle {@code null} ist. + */ public Sound( String source ) { + Validator.requireNotNull(source); this.audioSource = source; } + /** + * {@inheritDoc} + */ + @Override public boolean isPlaying() { // return audioClip != null && audioClip.isRunning(); return playing; } + /** + * {@inheritDoc} + */ + @Override public boolean isLooping() { if( !playing ) { looping = false; @@ -37,6 +86,10 @@ public class Sound implements Audio { return looping; } + /** + * {@inheritDoc} + */ + @Override public void setVolume( double volume ) { this.volume = (float) volume; if( audioClip != null ) { @@ -44,6 +97,18 @@ public class Sound implements Audio { } } + /** + * {@inheritDoc} + */ + @Override + public double getVolume() { + return volume; + } + + /** + * Interne Methode, um die gesetzte Lautstärke vor dem Abspielen + * anzuwenden. + */ private void applyVolume() { FloatControl gainControl = (FloatControl) audioClip.getControl(FloatControl.Type.MASTER_GAIN); @@ -53,6 +118,10 @@ public class Sound implements Audio { gainControl.setValue(vol); } + /** + * {@inheritDoc} + */ + @Override public void stop() { looping = false; if( audioClip.isRunning() ) { @@ -61,6 +130,10 @@ public class Sound implements Audio { playing = false; } + /** + * {@inheritDoc} + */ + @Override public void play() { if( this.openClip() ) { audioClip.start(); @@ -68,16 +141,10 @@ public class Sound implements Audio { } } - public void playOnce() { - disposeAfterPlay = true; - play(); - } - - public void playOnceAndWait() { - disposeAfterPlay = true; - playAndWait(); - } - + /** + * {@inheritDoc} + */ + @Override public void playAndWait() { this.play(); @@ -94,26 +161,73 @@ public class Sound implements Audio { audioClip.close(); } + /** + * Spielt den Sound genau einmal ab und gibt danach alle Resourcen des Clips + * frei. + *
+ * Der Aufruf ist effektiv gleich zu + *
+ * clip.playAndWait();
+ * clip.dispose();
+ * + * Der Aufruf entspricht + *
+ * clip.playAndWait();
+ * clip.dispose();
+ *
* Unterklassen sollten diese Methode überschreiben, um weitere
* Eigenschaften zu kopieren (zum Beispiel den Radius eines Kreises). Mit
- * dem Aufruf
- * super.copyFrom(shape) sollten die Basiseigenschaften
+ * dem Aufruf {@code super.copyFrom(shape)} sollten die Basiseigenschaften
* kopiert werden.
*
* @param shape
@@ -243,7 +242,7 @@ public abstract class Shape extends FilledShape {
}
public void alignTo( Options.Direction dir, double buff ) {
- Point2D anchorShape = Shape.getAnchorPoint(width, height, dir);
+ Point2D anchorShape = Shape.getAnchorPoint(canvasWidth, canvasHeight, dir);
Point2D anchorThis = this.getAbsAnchorPoint(dir);
this.x += Math.abs(dir.x) * (anchorShape.getX() - anchorThis.getX()) + dir.x * buff;
diff --git a/src/main/java/schule/ngb/zm/shapes/ShapeGroup.java b/src/main/java/schule/ngb/zm/shapes/ShapeGroup.java
index 46a56d5..b8548da 100644
--- a/src/main/java/schule/ngb/zm/shapes/ShapeGroup.java
+++ b/src/main/java/schule/ngb/zm/shapes/ShapeGroup.java
@@ -5,6 +5,7 @@ import schule.ngb.zm.Options;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Path2D;
+import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
@@ -28,9 +29,20 @@ import java.util.List;
* benötigen, erst nach Hinzufügen der Gruppenelemente ausgeführt werden.
* Nachdem sich die Zusammensetzung der Gruppe geändert hat, muss die Gruppe
* ggf. neu ausgerichtet werden.
+ *
+ * Für die Ausrichtung der Elemente in einer Gruppe können
+ * {@link #arrange(Options.Direction, double)},
+ * {@link #arrangeInGrid(int, Options.Direction, double, int)} und
+ * {@link #align(Options.Direction)} verwendet werden, die jeweils die Position
+ * der Formen in der Gruppe ändern und nicht die Position der Gruppe selbst (so
+ * wie z.B. {@link #alignTo(Shape, Options.Direction)}.
*/
public class ShapeGroup extends Shape {
+ public static final int ARRANGE_ROWS = 0;
+
+ public static final int ARRANGE_COLS = 1;
+
private List
+ * Die Implementierung basiert auf dem von Ken Perlin entwickelten Algorithmus
+ * und wurde anhand der Beschreibung von
+ * FLAFLA2 implementiert.
+ */
+public class Noise {
+
+ private static final int N = 256;
+
+ private static final int M = N - 1;
+
+ /**
+ * Interne Permutationstabelle für diesen Generator
+ */
+ private int[] p;
+
+ private double octaves = 1, persistence = .5;
+
+ private double frequency = 1;
+
+ private double amplitude = 1;
+
+ private int repeat = -1;
+
+ private double rangeMin = 0.0, rangeMax = 1.0;
+
+ public Noise() {
+ this(null);
+ }
+
+ public Noise( long seed ) {
+ init(new Random(seed));
+ }
+
+ /**
+ * Initialisiert diesen Perlin-Noise mit dem angegebenen Zufallsgenerator.
+ *
+ * @param rand
+ */
+ public Noise( Random rand ) {
+ init(rand);
+ }
+
+ public double getOctaves() {
+ return octaves;
+ }
+
+ public void setOctaves( double pOctaves ) {
+ this.octaves = pOctaves;
+ }
+
+ public double getPersistence() {
+ return persistence;
+ }
+
+ public void setPersistence( double pPersistence ) {
+ this.persistence = pPersistence;
+ }
+
+ public double getFrequency() {
+ return frequency;
+ }
+
+ public void setFrequency( double pFrequency ) {
+ this.frequency = pFrequency;
+ }
+
+ public double getAmplitude() {
+ return amplitude;
+ }
+
+ public void setAmplitude( double pAmplitude ) {
+ this.amplitude = pAmplitude;
+ }
+
+ public void setRange( double pRangeMin, double pRangeMax ) {
+ this.rangeMin = pRangeMin;
+ this.rangeMax = pRangeMax;
+ }
+
+ public double getRangeMin() {
+ return rangeMin;
+ }
+
+ public double getRangeMax() {
+ return rangeMax;
+ }
+
+ public int getRepeat() {
+ return repeat;
+ }
+
+ public void setRepeat( int pRepeat ) {
+ this.repeat = pRepeat;
+ }
+
+ public double noise( double x ) {
+ double total = 0;
+ double freq = this.frequency;
+ double amp = this.amplitude;
+ double maxValue = 0;
+
+ for( int i = 0; i < octaves; i++ ) {
+ total += perlin(x * freq) * amp;
+
+ maxValue += amp;
+
+ amp *= persistence;
+ freq *= 2;
+ }
+
+ return lerp(rangeMin, rangeMax, (total / maxValue));
+ }
+
+ public double noise( double x, double y ) {
+ double total = 0;
+ double freq = this.frequency;
+ double amp = this.amplitude;
+ double maxValue = 0;
+
+ for( int i = 0; i < octaves; i++ ) {
+ total += perlin(x * freq, y * freq) * amp;
+
+ maxValue += amp;
+
+ amp *= persistence;
+ freq *= 2;
+ }
+
+ return lerp(rangeMin, rangeMax, (total / maxValue));
+ }
+
+ public double noise( double x, double y, double z ) {
+ double total = 0;
+ double freq = this.frequency;
+ double amp = this.amplitude;
+ double maxValue = 0;
+
+ for( int i = 0; i < octaves; i++ ) {
+ total += perlin(x * freq, y * freq, z * freq) * amp;
+
+ maxValue += amp;
+
+ amp *= persistence;
+ freq *= 2;
+ }
+
+ return lerp(rangeMin, rangeMax, (total / maxValue));
+ }
+
+ private double perlin( double x ) {
+ // @formatter:off
+ if( repeat > 0 ) {
+ x %= repeat;
+ }
+
+ int xi = (int)x & M;
+
+ double xf = x - (int)x;
+
+ double u = fade(xf);
+
+ int a, b;
+ a = p[ xi ];
+ b = p[inc(xi)];
+
+ return (lerp(grad(a,xf), grad(b,xf-1), u) + 1) / 2;
+ // @formatter:on
+ }
+
+ private double perlin( double x, double y ) {
+ // @formatter:off
+ if( repeat > 0 ) {
+ x %= repeat;
+ y %= repeat;
+ }
+
+ int xi = (int) x & M;
+ int yi = (int) y & M;
+
+ double xf = x - (int) x;
+ double yf = y - (int) y;
+
+ double u = fade(xf);
+ double v = fade(yf);
+
+ int aa, ab, ba, bb;
+ aa = p[p[ xi ] + yi ];
+ ab = p[p[ xi ] + inc(yi)];
+ ba = p[p[inc(xi)] + yi ];
+ bb = p[p[inc(xi)] + inc(yi)];
+
+ double x1, x2;
+ x1 = lerp(
+ grad(aa, xf , yf),
+ grad(ba, xf-1, yf),
+ u);
+ x2 = lerp(
+ grad(ab, xf , yf-1),
+ grad(bb, xf-1, yf-1),
+ u);
+
+ return (lerp(x1, x2, v) + 1) / 2;
+ // @formatter:on
+ }
+
+ private double perlin( double x, double y, double z ) {
+ // @formatter:off
+ if( repeat > 0 ) {
+ x %= repeat;
+ y %= repeat;
+ z %= repeat;
+ }
+
+ int xi = (int)x & M;
+ int yi = (int)y & M;
+ int zi = (int)z & M;
+ double xf = x - (int)x;
+ double yf = y - (int)y;
+ double zf = z - (int)z;
+
+ double u = fade(xf);
+ double v = fade(yf);
+ double w = fade(zf);
+
+ int aaa, aba, aab, abb, baa, bba, bab, bbb;
+ aaa = p[p[p[ xi ] + yi ] + zi ];
+ aba = p[p[p[ xi ] + inc(yi)] + zi ];
+ aab = p[p[p[ xi ] + yi ] + inc(zi)];
+ abb = p[p[p[ xi ] + inc(yi)] + inc(zi)];
+ baa = p[p[p[inc(xi)] + yi ] + zi ];
+ bba = p[p[p[inc(xi)] + inc(yi)] + zi ];
+ bab = p[p[p[inc(xi)] + yi ] + inc(zi)];
+ bbb = p[p[p[inc(xi)] + inc(yi)] + inc(zi)];
+
+ double x1, x2, y1, y2;
+ x1 = lerp(
+ grad(aaa, xf , yf, zf),
+ grad(baa, xf-1, yf, zf),
+ u);
+ x2 = lerp(
+ grad(aba, xf , yf-1, zf),
+ grad(bba, xf-1, yf-1, zf),
+ u);
+ y1 = lerp(x1, x2, v);
+
+ x1 = lerp(
+ grad(aab, xf , yf, zf-1),
+ grad(bab, xf-1, yf, zf-1),
+ u);
+ x2 = lerp(
+ grad(abb, xf , yf-1, zf-1),
+ grad(bbb, xf-1, yf-1, zf-1),
+ u);
+ y2 = lerp(x1, x2, v);
+
+ return (lerp(y1, y2, w) + 1) / 2;
+ // @formatter:on
+ }
+
+ public void init( Random rand ) {
+ p = new int[N * 2];
+
+ if( rand == null ) {
+ System.arraycopy(PERLIN_PERMUTATION, 0, p, 0, N);
+ } else {
+ // Generate random permutation
+ for( int i = 0; i < N; i++ ) {
+ int n = rand.nextInt(N);
+ if( p[n] == 0 )
+ p[n] = i;
+ else
+ i--;
+ }
+ }
+
+ // Duplicate permutation array to prevent overflow errors
+ System.arraycopy(p, 0, p, N, N);
+ }
+
+ private double fade( double t ) {
+ return t * t * t * (t * (t * 6 - 15) + 10);
+ }
+
+ private double lerp( double a, double b, double t ) {
+ return a + t * (b - a);
+ }
+
+ private int inc( int i ) {
+ ++i;
+ if( repeat > 0 )
+ i = i % repeat;
+ return i;
+ }
+
+ private double grad( int hash, double x ) {
+ switch( hash & 0x1 ) {
+ // @formatter:off
+ case 0x0: return x;
+ case 0x1: return -x;
+ default: return 0;
+ // @formatter:on
+ }
+ }
+
+
+ private double grad( int hash, double x, double y ) {
+ switch( hash & 0x3 ) {
+ // @formatter:off
+ case 0x0: return x;
+ case 0x1: return -x;
+ case 0x2: return y;
+ case 0x3: return -y;
+ default: return 0;
+ // @formatter:on
+ }
+ }
+
+ private double grad( int hash, double x, double y, double z ) {
+ switch( hash & 0xF ) {
+ // @formatter:off
+ case 0x0: return x + y;
+ case 0x1: return -x + y;
+ case 0x2: return x - y;
+ case 0x3: return -x - y;
+ case 0x4: return x + z;
+ case 0x5: return -x + z;
+ case 0x6: return x - z;
+ case 0x7: return -x - z;
+ case 0x8: return y + z;
+ case 0x9: return -y + z;
+ case 0xA: return y - z;
+ case 0xB: return -y - z;
+ case 0xC: return y + x;
+ case 0xD: return -y + z;
+ case 0xE: return y - x;
+ case 0xF: return -y - z;
+ default: return 0; // never happens
+ // @formatter:on
+ }
+ }
+
+ private static final int[] PERLIN_PERMUTATION = new int[]{
+ 151, 160, 137, 91, 90, 15,
+ 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
+ 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
+ 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
+ 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244,
+ 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196,
+ 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123,
+ 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42,
+ 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
+ 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228,
+ 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107,
+ 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
+ 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
+ };
+
+}
diff --git a/src/main/java/schule/ngb/zm/util/Validator.java b/src/main/java/schule/ngb/zm/util/Validator.java
index 50067b9..cb28143 100644
--- a/src/main/java/schule/ngb/zm/util/Validator.java
+++ b/src/main/java/schule/ngb/zm/util/Validator.java
@@ -136,8 +136,27 @@ public class Validator {
}
*/
+
+ public static final null, wenn das Bild nicht geladen werden
+ * Bild zurück oder {@code null}, wenn das Bild nicht geladen werden
* konnte. Ist ein Bild mit der angegebenen Quelle im Cache, wird das
* gespeicherte Bild zurückgegeben. Dies kann mit {@code caching = false}
* verhindert werden.
diff --git a/src/main/java/schule/ngb/zm/util/Noise.java b/src/main/java/schule/ngb/zm/util/Noise.java
new file mode 100644
index 0000000..e638f49
--- /dev/null
+++ b/src/main/java/schule/ngb/zm/util/Noise.java
@@ -0,0 +1,366 @@
+package schule.ngb.zm.util;
+
+import java.util.Random;
+
+/**
+ * Zufallsgenerator für Perlin-Noise.
+ *