Klasse Constants kommentiert und refactored

src/main/java/schule/ngb/zm/Color.java

@@ -3,17 +3,15 @@ package schule.ngb.zm;
 /**
  * Repräsentiert eine Farbe in der Zeichenmaschine.
  * <p>
- * Farben bestehen entweder aus einem Grauwert (zwischen 0 und
+ * Farben bestehen entweder aus einem Grauwert (zwischen 0 und 255) oder einem
- * 255) oder einem Rot-, Grün- und Blauanteil (jeweils zwischen
+ * Rot-, Grün- und Blauanteil (jeweils zwischen 0 und 255).
- * 0 und 255).
  * <p>
- * Eine Farbe hat außerdem einen Transparenzwert zwischen 0
+ * Eine Farbe hat außerdem einen Transparenzwert zwischen 0 (unsichtbar) und 255
- * (unsichtbar) und 255 (deckend).
+ * (deckend).
  */
 public class Color {
 
 
-
 	//@formatter:off
 	/**
 	 * Die Farbe Schwarz (Grauwert 0).
@@ -124,12 +122,12 @@ public class Color {
 
 	/**
 	 * Erstellt eine Farbe. Die Parameter <var>red</var>, <var>green</var> und
-	 * <var>blue</var> geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte
+	 * <var>blue</var> geben die Rot-, Grün- und Blauanteile der Farbe. Die
-	 * liegen zwischen 0 und 255.
+	 * 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,16 +135,14 @@ public class Color {
 
 	/**
 	 * Erstellt eine Farbe. Die Parameter <var>red</var>, <var>green</var> und
-	 * <var>blue</var> geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte
+	 * <var>blue</var> geben die Rot-, Grün- und Blauanteile der Farbe. Die
-	 * liegen zwischen 0 und 255.
+	 * Werte liegen zwischen 0 und 255.
 	 * <var>alpha</var> gibt den den Transparentwert an (auch zwischen
-	 * 0 und 255), wobei
+	 * 0 und 255), wobei 0 komplett durchsichtig ist und 255 komplett deckend.
-	 * 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 ) {
@@ -184,10 +180,11 @@ public class Color {
 	/**
 	 * Interner Konstruktor für die Initialisierung einer Farbe mit einem
 	 * RGBA-Wert.
-	 *
+	 * <p>
 	 * Da der Konstruktor {@link #Color(int)} schon besetzt ist, muss hier der
-	 * Parameter {@code isRGBA} auf {@code true} gesetzt werden, damit {@code rgba}
+	 * Parameter {@code isRGBA} auf {@code true} gesetzt werden, damit
-	 * korrekt interpretiert wird.
+	 * {@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) {
+	public static Color getHSBColor( double h, double s, double b ) {
-		return new Color(java.awt.Color.getHSBColor((float)h, (float)s, (float)b));
+		return new Color(java.awt.Color.getHSBColor((float) h, (float) s, (float) b));
 	}
 
-	public static Color getHSLColor(double h, double s, double l) {
+	public static Color getHSLColor( double h, double s, double l ) {
-		int rgb = Color.HSLtoRGB(new float[]{(float)h, (float)s, (float)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
+	 * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann sechs-
-	 * sechs- oder achtstellig sein (wenn ein Transparentwert vorhanden ist).
+	 * oder achtstellig sein (wenn ein Transparentwert vorhanden ist). Dem Code
-	 * Dem Code kann ein {@code #} Zeichen vorangestellt sein.
+	 * 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.
-	 *
+	 * <p>
 	 * 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.
-	 *
+	 * <p>
-	 * Eine Farbe wird als 32-Bit Integer gespeichert. Bits 24-31 enthalten
+	 * Eine Farbe wird als 32-Bit Integer gespeichert. Bits 24-31 enthalten den
-	 * den Transparenzwert, 16-23 den Rotwert, 8-15 den Grünwert und 0-7 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.
+	 * <p>
+	 * 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,12 @@ 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;
+		return obj instanceof Color && ((Color) obj).getRGBA() == this.rgba;
 	}
 
 	/**
 	 * Erzeugt einen Text-String, der diese Farbe beschreibt.
+	 *
 	 * @return Eine Textversion der Farbe.
 	 */
 	@Override
@@ -482,6 +488,7 @@ public class Color {
 
 	/**
 	 * Berechnet einen Hashcode für dieses Farbobjekt.
+	 *
 	 * @return Ein Hashcode für diese Rabe.
 	 */
 	@Override
@@ -490,7 +497,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 +507,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 +519,7 @@ public class Color {
 
 	/**
 	 * Erzeugt eine um 30% dunklere Version dieser Farbe.
+	 *
 	 * @return Ein Farbobjekt mit einer dunkleren Farbe.
 	 */
 	public Color darker() {
@@ -518,6 +528,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 +539,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 +554,7 @@ public class Color {
 
 	/**
 	 * Erzeugt die Komplementärfarbe zu dieser.
+	 *
 	 * @return Ein Farbobjekt mit der Komplementärfarbe.
 	 */
 	public Color complement() {
@@ -554,11 +567,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;

src/main/java/schule/ngb/zm/Options.java

@@ -56,7 +56,12 @@ public final class Options {
 		UP(NORTH),
 		DOWN(SOUTH),
 		LEFT(WEST),
-		RIGHT(EAST);
+		RIGHT(EAST),
+
+		UPLEFT(NORTHWEST),
+		DOWNLEFT(SOUTHWEST),
+		UPRIGHT(NORTHEAST),
+		DOWNRIGHT(SOUTHEAST);
 
 		public final byte x, y;
 

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));
 		}
 	}
 

src/main/java/schule/ngb/zm/Zeichenmaschine.java

@@ -277,8 +277,8 @@ public class Zeichenmaschine extends Constants {
 		}
 
 		// Wir kennen nun den Bildschirm und können die Breite / Höhe abrufen.
-		this.width = width;
+		this.canvasWidth = width;
-		this.height = height;
+		this.canvasHeight = height;
 		java.awt.Rectangle displayBounds = displayDevice.getDefaultConfiguration().getBounds();
 		this.screenWidth = (int) displayBounds.getWidth();
 		this.screenHeight = (int) displayBounds.getHeight();
@@ -408,8 +408,8 @@ public class Zeichenmaschine extends Constants {
 				frame.setResizable(false); // Should be set anyway
 				displayDevice.setFullScreenWindow(frame);
 				// Update width / height
-				initialWidth = width;
+				initialWidth = canvasWidth;
-				initialHeight = height;
+				initialHeight = canvasHeight;
 				changeSize(screenWidth, screenHeight);
 				// Register ESC as exit fullscreen
 				canvas.addKeyListener(fullscreenExitListener);
@@ -595,11 +595,11 @@ public class Zeichenmaschine extends Constants {
 	 * @see #setFullscreen(boolean)
 	 */
 	private void changeSize( int newWidth, int newHeight ) {
-		width = Math.min(Math.max(newWidth, 100), screenWidth);
+		canvasWidth = Math.min(Math.max(newWidth, 100), screenWidth);
-		height = Math.min(Math.max(newHeight, 100), screenHeight);
+		canvasHeight = Math.min(Math.max(newHeight, 100), screenHeight);
 
 		if( canvas != null ) {
-			canvas.setSize(width, height);
+			canvas.setSize(canvasWidth, canvasHeight);
 		}
 	}
 
@@ -629,7 +629,7 @@ public class Zeichenmaschine extends Constants {
 	 * @return Die Breite der {@link Zeichenleinwand}.
 	 */
 	public final int getWidth() {
-		return width;
+		return canvasWidth;
 	}
 
 	/**
@@ -638,7 +638,7 @@ public class Zeichenmaschine extends Constants {
 	 * @return Die Höhe der {@link Zeichenleinwand}.
 	 */
 	public final int getHeight() {
-		return height;
+		return canvasHeight;
 	}
 
 	/**
@@ -718,7 +718,7 @@ public class Zeichenmaschine extends Constants {
 	public final ColorLayer getBackgroundLayer() {
 		ColorLayer layer = canvas.getLayer(ColorLayer.class);
 		if( layer == null ) {
-			layer = new ColorLayer(STD_BACKGROUND);
+			layer = new ColorLayer(DEFAULT_BACKGROUND);
 			canvas.addLayer(0, layer);
 		}
 		return layer;
@@ -812,7 +812,7 @@ public class Zeichenmaschine extends Constants {
 		BufferedImage img = ImageLoader.createImage(canvas.getWidth(), canvas.getHeight());
 
 		Graphics2D g = img.createGraphics();
-		g.setColor(STD_BACKGROUND.getJavaColor());
+		g.setColor(DEFAULT_BACKGROUND.getJavaColor());
 		g.fillRect(0, 0, img.getWidth(), img.getHeight());
 		canvas.draw(g);
 		g.dispose();
@@ -836,7 +836,7 @@ public class Zeichenmaschine extends Constants {
 		BufferedImage img = ImageLoader.createImage(canvas.getWidth(), canvas.getHeight());
 
 		Graphics2D g = img.createGraphics();
-		g.setColor(STD_BACKGROUND.getJavaColor());
+		g.setColor(DEFAULT_BACKGROUND.getJavaColor());
 		g.fillRect(0, 0, img.getWidth(), img.getHeight());
 		canvas.draw(g);
 		g.dispose();
@@ -1166,7 +1166,7 @@ public class Zeichenmaschine extends Constants {
 				break;
 			case MouseEvent.MOUSE_RELEASED:
 				mousePressed = false;
-				mouseButton = NOBUTTON;
+				mouseButton = NOMOUSE;
 				mousePressed(evt);
 				break;
 			case MouseEvent.MOUSE_DRAGGED:

src/main/java/schule/ngb/zm/shapes/Shape.java

@@ -243,7 +243,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;

src/main/java/schule/ngb/zm/util/Noise.java

@@ -0,0 +1,308 @@
+package schule.ngb.zm.util;
+
+import java.util.Random;
+
+/**
+ * Zufallsgenerator für Perlin-Noise.
+ * <p>
+ * Die Implementierung basiert auf dem von Ken perlin entwickelten Algorithmus
+ * und wurde von Matthew A. Johnston für Java implementiert.
+ * <p>
+ * Original KOmmentar:
+ * <pre>
+ * This is Ken Perlin's implementation of Perlin Noise but modified to be more
+ * OOP.
+ * </pre>
+ *
+ * @author Ken Perlin, Matthew A. Johnston (WarmWaffles)
+ */
+public class Noise {
+
+	private Random rand;
+
+	private static final int P = 8;
+
+	private static final int B = 1 << P;
+
+	private static final int M = B - 1;
+
+	private static final int NP = 8;
+
+	private static final int N = 1 << NP;
+
+	private int[] p;
+
+	private double[][] g2;
+
+	private double[] g1;
+
+	private static double[][] points;
+
+
+	public Noise() {
+		this(System.nanoTime());
+	}
+
+	public Noise( long seed ) {
+		this(new Random(seed));
+	}
+
+	public Noise( Random rand ) {
+		p = new int[B + B + 2];
+		g2 = new double[B + B + 2][2];
+		g1 = new double[B + B + 2];
+
+		points = new double[32][3];
+
+		this.rand = rand;
+		init();
+	}
+
+	/**
+	 * A stub function that calls {@link #init()}
+	 *
+	 * @param seed
+	 */
+	public void setSeed( int seed ) {
+		this.rand = new Random(seed);
+		init();
+	}
+
+	public void setRandom( Random rand ) {
+		this.rand = rand;
+		init();
+	}
+
+	public double noise( double x, double y, double z ) {
+		int bx, by, bz, b0, b1, b00, b10, b01, b11;
+		double rx0, rx1, ry0, ry1, rz, sx, sy, sz, a, b, c, d, u, v, q[];
+
+		bx = (int) Math.IEEEremainder(Math.floor(x), B);
+		if( bx < 0 )
+			bx += B;
+
+		rx0 = x - Math.floor(x);
+		rx1 = rx0 - 1;
+
+		by = (int) Math.IEEEremainder(Math.floor(y), B);
+		if( by < 0 )
+			by += B;
+
+		ry0 = y - Math.floor(y);
+		ry1 = ry0 - 1;
+
+		bz = (int) Math.IEEEremainder(Math.floor(z), B);
+		if( bz < 0 )
+			bz += B;
+
+		rz = z - Math.floor(z);
+
+		/*
+		if (bx < 0 || bx >= B + B + 2)
+			System.out.println(bx);
+		*/
+		b0 = p[bx];
+
+		bx++;
+
+		b1 = p[bx];
+
+		b00 = p[b0 + by];
+		b10 = p[b1 + by];
+
+		by++;
+
+		b01 = p[b0 + by];
+		b11 = p[b1 + by];
+
+		sx = s_curve(rx0);
+		sy = s_curve(ry0);
+		sz = s_curve(rz);
+
+		q = G(b00 + bz);
+		u = rx0 * q[0] + ry0 * q[1] + rz * q[2];
+		q = G(b10 + bz);
+		v = rx1 * q[0] + ry0 * q[1] + rz * q[2];
+		a = lerp(sx, u, v);
+		q = G(b01 + bz);
+		u = rx0 * q[0] + ry1 * q[1] + rz * q[2];
+		q = G(b11 + bz);
+		v = rx1 * q[0] + ry1 * q[1] + rz * q[2];
+		b = lerp(sx, u, v);
+		c = lerp(sy, a, b);
+
+		bz++;
+		rz--;
+
+		q = G(b00 + bz);
+		u = rx0 * q[0] + ry0 * q[1] + rz * q[2];
+		q = G(b10 + bz);
+		v = rx1 * q[0] + ry0 * q[1] + rz * q[2];
+		a = lerp(sx, u, v);
+		q = G(b01 + bz);
+		u = rx0 * q[0] + ry1 * q[1] + rz * q[2];
+		q = G(b11 + bz);
+		v = rx1 * q[0] + ry1 * q[1] + rz * q[2];
+		b = lerp(sx, u, v);
+		d = lerp(sy, a, b);
+
+		return lerp(sz, c, d);
+	}
+
+	public double noise( double x, double y ) {
+		int bx0, bx1, by0, by1, b00, b10, b01, b11;
+		double rx0, rx1, ry0, ry1, sx, sy, a, b, t, u, v, q[];
+		int i, j;
+
+		t = x + N;
+		bx0 = ((int) t) & M;
+		bx1 = (bx0 + 1) & M;
+		rx0 = t - (int) t;
+		rx1 = rx0 - 1;
+
+		t = y + N;
+		by0 = ((int) t) & M;
+		by1 = (by0 + 1) & M;
+		ry0 = t - (int) t;
+		ry1 = ry0 - 1;
+
+		i = p[bx0];
+		j = p[bx1];
+
+		b00 = p[i + by0];
+		b10 = p[j + by0];
+		b01 = p[i + by1];
+		b11 = p[j + by1];
+
+		sx = s_curve(rx0);
+		sy = s_curve(ry0);
+
+		q = g2[b00];
+		u = rx0 * q[0] + ry0 * q[1];
+		q = g2[b10];
+		v = rx1 * q[0] + ry0 * q[1];
+		a = lerp(sx, u, v);
+
+		q = g2[b01];
+		u = rx0 * q[0] + ry1 * q[1];
+		q = g2[b11];
+		v = rx1 * q[0] + ry1 * q[1];
+		b = lerp(sx, u, v);
+
+		return lerp(sy, a, b);
+	}
+
+	public double noise( double x ) {
+
+		int bx0, bx1;
+		double rx0, rx1, sx, t, u, v;
+		t = x + N;
+		bx0 = ((int) t) & M;
+		bx1 = (bx0 + 1) & M;
+		rx0 = t - (int) t;
+		rx1 = rx0 - 1;
+
+		sx = s_curve(rx0);
+		u = rx0 * g1[p[bx0]];
+		v = rx1 * g1[p[bx1]];
+
+		return lerp(sx, u, v);
+	}
+
+	// ========================================================================
+	//                             PRIVATE
+	// ========================================================================
+	private void normalize2( double v[] ) {
+		double s;
+		s = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+		v[0] = v[0] / s;
+		v[1] = v[1] / s;
+	}
+
+	private double[] G( int i ) {
+		return points[i % 32];
+	}
+
+	private double s_curve( double t ) {
+		return t * t * (3 - t - t);
+	}
+
+	private double lerp( double t, double a, double b ) {
+		return a + t * (b - a);
+	}
+
+	private final void init() {
+		int i, j, k;
+		double u, v, w, U, V, W, Hi, Lo;
+
+		for( i = 0; i < B; i++ ) {
+			p[i] = i;
+			g1[i] = 2 * rand.nextDouble() - 1;
+
+			do {
+				u = 2 * rand.nextDouble() - 1;
+				v = 2 * rand.nextDouble() - 1;
+			} while( u * u + v * v > 1 ||
+				Math.abs(u) > 2.5 * Math.abs(v) ||
+				Math.abs(v) > 2.5 * Math.abs(u) ||
+				Math.abs(Math.abs(u) - Math.abs(v)) < .4 );
+
+			g2[i][0] = u;
+			g2[i][1] = v;
+
+			normalize2(g2[i]);
+
+			do {
+				u = 2 * rand.nextDouble() - 1;
+				v = 2 * rand.nextDouble() - 1;
+				w = 2 * rand.nextDouble() - 1;
+				U = Math.abs(u);
+				V = Math.abs(v);
+				W = Math.abs(w);
+				Lo = Math.min(U, Math.min(V, W));
+				Hi = Math.max(U, Math.max(V, W));
+			} while( u * u + v * v + w * w > 1
+				|| Hi > 4 * Lo
+				|| Math.min(Math.abs(U - V),
+				Math.min(Math.abs(U - W), Math.abs(V - W))) < .2 );
+		}
+
+		while( --i > 0 ) {
+			k = p[i];
+			j = (int) (rand.nextLong() & M);
+			p[i] = p[j];
+			p[j] = k;
+		}
+		for( i = 0; i < B + 2; i++ ) {
+			p[B + i] = p[i];
+			g1[B + i] = g1[i];
+			for( j = 0; j < 2; j++ )
+				g2[B + i][j] = g2[i][j];
+		}
+
+		points[3][0] = points[3][1] = points[3][2] = Math.sqrt(1. / 3);
+		double r2 = Math.sqrt(1. / 2);
+		double s = Math.sqrt(2 + r2 + r2);
+
+		for( i = 0; i < 3; i++ )
+			for( j = 0; j < 3; j++ )
+				points[i][j] = (i == j ? 1 + r2 + r2 : r2) / s;
+
+
+		for( i = 0; i <= 1; i++ ) {
+			for( j = 0; j <= 1; j++ ) {
+				for( k = 0; k <= 1; k++ ) {
+					int n = i + j * 2 + k * 4;
+					if( n > 0 ) {
+						for( int m = 0; m < 4; m++ ) {
+							points[4 * n + m][0] = (i == 0 ? 1 : -1) * points[m][0];
+							points[4 * n + m][1] = (j == 0 ? 1 : -1) * points[m][1];
+							points[4 * n + m][2] = (k == 0 ? 1 : -1) * points[m][2];
+						}
+					}
+				}
+			}
+		}
+	}
+
+}

src/main/java/schule/ngb/zm/util/Validator.java

@@ -136,8 +136,27 @@ public class Validator {
 	}
 	*/
 
+
+	public static final <T> T[] requireNotEmpty( T[] arr ) {
+		return requireNotEmpty(arr, (Supplier<String>)null);
+	}
+
+	public static final <T> T[] requireNotEmpty( T[] arr, CharSequence msg ) {
+		return requireNotEmpty(arr, msg::toString);
+	}
+
 	public static final <T> T[] requireNotEmpty( T[] arr, Supplier<String> msg ) {
-		return requireSize(arr, 0, ()->"Parameter array may not be empty");
+		if( arr.length == 0 )
+			throw new IllegalArgumentException(msg == null ? String.format("Parameter array may not be empty") : msg.get());
+		return arr;
+	}
+
+	public static final <T> T[] requireSize( T[] arr, int size ) {
+		return requireSize(arr, size, (Supplier<String>)null);
+	}
+
+	public static final <T> T[] requireSize( T[] arr, int size, CharSequence msg ) {
+		return requireSize(arr, size, msg::toString);
 	}
 
 	public static final <T> T[] requireSize( T[] arr, int size, Supplier<String> msg ) {
@@ -146,6 +165,20 @@ public class Validator {
 		return arr;
 	}
 
+	public static final <T> T[] requireValid( T[] arr ) {
+		return requireValid(arr, (Supplier<String>)null);
+	}
+
+	public static final<T> T[] requireValid( T[] arr, CharSequence msg ) {
+		return requireValid(arr, msg::toString);
+	}
+
+	public static final <T> T[] requireValid( T[] arr, Supplier<String> msg ) {
+		if( arr == null || arr.length > 0 )
+			throw new IllegalArgumentException(msg == null ? String.format("Parameter array may not be null or empty") : msg.get());
+		return arr;
+	}
+
 	private Validator() {
 	}
 

src/test/java/schule/ngb/zm/ConstantsTest.java

@@ -72,22 +72,22 @@ class ConstantsTest {
 
 	@Test
 	void b() {
-		assertTrue(Constants.getBool(true));
+		assertTrue(Constants.asBool(true));
-		assertFalse(Constants.getBool(false));
+		assertFalse(Constants.asBool(false));
-		assertTrue(Constants.getBool(1));
+		assertTrue(Constants.asBool(1));
-		assertFalse(Constants.getBool(0));
+		assertFalse(Constants.asBool(0));
-		assertTrue(Constants.getBool(4.0));
+		assertTrue(Constants.asBool(4.0));
-		assertFalse(Constants.getBool(0.0));
+		assertFalse(Constants.asBool(0.0));
-		assertTrue(Constants.getBool(4.0f));
+		assertTrue(Constants.asBool(4.0f));
-		assertFalse(Constants.getBool(0.0f));
+		assertFalse(Constants.asBool(0.0f));
-		assertTrue(Constants.getBool(4L));
+		assertTrue(Constants.asBool(4L));
-		assertFalse(Constants.getBool(0L));
+		assertFalse(Constants.asBool(0L));
-		assertTrue(Constants.getBool("true"));
+		assertTrue(Constants.asBool("true"));
-		assertTrue(Constants.getBool("True"));
+		assertTrue(Constants.asBool("True"));
-		assertFalse(Constants.getBool("1"));
+		assertFalse(Constants.asBool("1"));
-		assertFalse(Constants.getBool("false"));
+		assertFalse(Constants.asBool("false"));
-		assertFalse(Constants.getBool("yes"));
+		assertFalse(Constants.asBool("yes"));
-		assertFalse(Constants.getBool("no"));
+		assertFalse(Constants.asBool("no"));
 	}
 
 	@Test

src/test/java/schule/ngb/zm/TestAttraction.java

@@ -38,7 +38,7 @@ public class TestAttraction extends Zeichenmaschine {
         posC = new Vector(200, 100);
         velC = new Vector(1, 14);
 
-        drawing.translate(width /2, height /2);
+        drawing.translate(canvasWidth /2, canvasHeight /2);
         drawing.shear(0.1, 0.5);
 
         recht = new Rectangle(50, 50, 150, 75);
@@ -84,7 +84,7 @@ public class TestAttraction extends Zeichenmaschine {
 
         shapes.clear();
 				double x = recht.getX();
-        x = (x+100*delta)% width;
+        x = (x+100*delta)% canvasWidth;
 				recht.setX(x);
     }
 

src/test/java/schule/ngb/zm/TestShapes.java

@@ -7,7 +7,6 @@ import schule.ngb.zm.shapes.Rectangle;
 import schule.ngb.zm.shapes.Shape;
 
 import java.awt.geom.Point2D;
-import java.util.Random;
 
 public class TestShapes extends Zeichenmaschine {
 
@@ -65,7 +64,7 @@ public class TestShapes extends Zeichenmaschine {
 
 	public void shapePositions() {
 		int pad = 24;
-		Rectangle bounds = new Rectangle(pad, pad, width-pad, height-pad);
+		Rectangle bounds = new Rectangle(pad, pad, canvasWidth -pad, canvasHeight -pad);
 
 		Rectangle[] rects = new Rectangle[5];
 		for( int i = 0; i < rects.length; i++ ) {