Updated ParticleEmitters and Factories

Ein Cache kann nun auch mit `WeakReference`n genutzt werden.

.gitignore

@@ -34,6 +34,7 @@ hs_err_pid*
 Thumbs.db
 
 .gradle
+local.properties
 **/build/
 !src/**/build/
 

CHANGELOG.md

@@ -6,6 +6,25 @@ und diese Projekt folgt [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## Added 
+- Dokumentation erweitert.
+- Caching-Mechanismen in Klasse `util.Cache` ausgelagert. 
+  - `util.io.ImageLoader` und `util.io.FontLoader` verwenden `Cache`.
+- `mouseWheelMoved` Eventhandler für Mausrad.
+- `DrawingLayer.imageRotate(...)` Methoden, um Bilder um ihr Zentrum gedreht zu zeichnen.
+
+## Changed
+- Die Methoden in `Validator` erwarten nun als zweiten Parameter den Namen des Parameters, der geprüft wird.
+- `DrawingLayer.image(...)` mit Größenänderung umbenannt zu `imageScale(...)`.
+- Klassen in `schule.ngb.zm.util.io` werfen nun nur eine Warnung ohne Stack-Trace, wenn die Ressource nicht gefunden werden konnte.
+
+## Fixed
+- `Constants.choice(int...)` und `Constants.choice(double...)` wiederhergestellt.
+- Timing-Problem beim Aufruf von `AudioListener.playbackStopped()` in `Sound` behoben.
+
+## Removed
+- `layers.Shape2DLayer` ist nur noch im Test-Paket verfügbar.
+
 ## Version 0.0.34
 
 ### Added

build.gradle

@@ -1,10 +1,11 @@
 plugins {
 	id 'idea'
     id 'java-library'
+	id 'org.hidetake.ssh' version '2.10.1'
 }
 
 group 'schule.ngb'
-version '0.0.34-SNAPSHOT'
+version '0.0.35-SNAPSHOT'
 
 java {
 	withSourcesJar()
@@ -19,6 +20,15 @@ repositories {
     mavenCentral()
 }
 
+remotes {
+	uberspace {
+		host = 'westphal.uberspace.de'
+		user = 'ngb'
+		identity = file("${System.properties['user.home']}/.ssh/uberspace_rsa")
+		knownHosts = allowAnyHosts
+	}
+}
+
 dependencies {
     runtimeOnly 'com.googlecode.soundlibs:jlayer:1.0.1.4'
 	runtimeOnly 'com.googlecode.soundlibs:tritonus-share:0.3.7.4'
@@ -33,10 +43,39 @@ dependencies {
 	testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
 }
 
+jar {
+	manifest {
+		attributes 'Class-Path': '.'
+	}
+}
+
+tasks.register('jarMP3SPI', Jar) {
+	group "build"
+	description "Build jar with MP3SPI included"
+
+	archiveClassifier = 'mp3spi'
+	duplicatesStrategy = 'exclude'
+	// archivesBaseName = 'zeichenmaschine-mp3spi'
+	from {
+		configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
+	}
+	with jar
+}
+
+task buildAll {
+	group "build"
+	description "Build all jar packages"
+
+	dependsOn 'jar'
+	dependsOn 'jarMP3SPI'
+	dependsOn 'sourcesJar'
+	dependsOn 'javadocJar'
+}
+
 javadoc {
 	options {
 		encoding = "UTF-8"
-		overview = "src/main/java/overview.html"
+		overview = "src/resources/java/overview.html"
 		// title = "Die Zeichenmaschine"
 
 		// options.links 'https://docs.oracle.com/javase/8/docs/api/'
@@ -46,16 +85,69 @@ javadoc {
 	options.addStringOption("charset", "UTF-8")
 }
 
-test {
-    useJUnitPlatform()
+task mkdocs(type: Exec) {
+	group "documentation"
+	description "Build MKDocs site"
+
+	workingDir "${projectDir}"
+	commandLine ".venv/bin/python", "-m", "mkdocs", "build"
 }
 
-tasks.register('jarMP3SPI', Jar) {
-	archiveClassifier = 'all'
-	duplicatesStrategy = 'exclude'
-	archivesBaseName = 'zeichenmaschine-mp3spi'
-	from {
-		configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
-	}
-	with jar
+task buildDocs {
+	group "documentation"
+	description "Run all documentation tasks"
+
+	dependsOn 'javadoc'
+	dependsOn 'javadocJar'
+	dependsOn 'mkdocs'
+}
+
+task zipSite(type: Zip) {
+	group "documentation"
+	description "Create zip archives for documentations"
+
+	dependsOn 'mkdocs'
+
+	from fileTree("${buildDir}/docs/site")
+	exclude '*.py'
+	exclude '__pycache__'
+	archiveName 'site.zip'
+	destinationDir(file("${buildDir}/docs"))
+}
+
+task zipJavadoc(type: Zip) {
+	group "documentation"
+	description "Create zip archives for javadoc"
+
+	dependsOn 'javadoc'
+
+	from fileTree("${buildDir}/docs/javadoc")
+	archiveName 'javadoc.zip'
+	destinationDir(file("${buildDir}/docs"))
+}
+
+task uploadDocs {
+	group "documentation"
+	description "Run all documentation tasks and upload artifacts to zeichenmaschine.xyz"
+
+	dependsOn 'zipSite'
+	dependsOn 'zipJavadoc'
+
+	doLast {
+		ssh.run {
+			session(remotes.uberspace) {
+				execute 'rm -rf /var/www/virtual/ngb/zeichenmaschine.xyz/*', ignoreError: true
+
+				put from: "${buildDir}/docs/site.zip", into: '/var/www/virtual/ngb/zeichenmaschine.xyz', ignoreError: true
+				execute 'unzip -o -q /var/www/virtual/ngb/zeichenmaschine.xyz/site.zip -d /var/www/virtual/ngb/zeichenmaschine.xyz'
+
+				put from: "${buildDir}/docs/javadoc.zip", into: '/var/www/virtual/ngb/zeichenmaschine.xyz', ignoreError: true
+				execute 'unzip  -o -q /var/www/virtual/ngb/zeichenmaschine.xyz/javadoc.zip -d /var/www/virtual/ngb/zeichenmaschine.xyz/docs'
+			}
+		}
+	}
+}
+
+test {
+	useJUnitPlatform()
 }

docs/einfuehrung.md

@@ -1,43 +0,0 @@
-
-<figure markdown>
-  ![Zeichenmaschine.xyz](assets/icon_512.png){ width=128 }
-</figure>
-
-<h1 class="title">Zeichenmaschine.xyz</h1>
-<h2 class="subtitle">Eine kleine Java-Bibliothek für grafische Programmierung im 
-Informatikunterricht.</h2>
-
-## Projektidee
-
-Die **Zeichenmaschine** ist eine für den Informatikunterricht entwickelte Bibliothek, 
-die unter anderem an [Processing](https://processing.org/) angelehnt ist. Die 
-Bibliothek soll einige der üblichen Anfängerschwierigkeiten mit Java vereinfachen 
-und für Schülerinnen und Schüler im Unterricht nutzbar machen.
-
-!!! warning
-
-	Das Projekt befindet sich noch in der Entwicklungsphase und auch wenn die 
-	aktuelle Version schon funktionsfähig ist und einen Großteil der angestrebten 
-	Funktionen enthält, ist noch keine stabile Version 1.0 erreicht. Vor allem 
-	am Umfang und konsistenten Design der APIs gilt es noch zu arbeiten und es 
-	können sich Änderungen ergeben.
-
-	Feedback und Vorschläge zu diesem Prozess (oder auch eine Beteiligung an der 
-	Entwicklung) können sehr gerne über [Github](https://github.com/jneug) oder 
-	[Mastodon](https://bildung.social/@ngb) an mich kommuniziert werden.
-	
-	(Gleiches gilt für diese Webseite zum Projekt.)
-
-## Dokumentation
-* [Schnellstart](quickstart.md)
-* [Installation](installation.md)
-* {{ javadoc_link() }}
-
-## Über die Zeichenmaschine
-
-!!! info
-
-	In der Zeichenmaschine werden bewusst nur englischsprachige Bezeichner für 
-	Klassen, Methoden und Variablen verwendet. Ausnahme sind einzelne Klassen,
-	die im Zusammnehang mit dem Namen der Bibliothek stehen, wie die
-	Hauptklasse `Zeichenmaschine`.

docs/index.md

@@ -0,0 +1,71 @@
+<figure markdown>
+  ![Zeichenmaschine.xyz](assets/icon_512.png){ width=128 }
+</figure>
+
+<h1 class="title">Zeichenmaschine.xyz</h1>
+<h2 class="subtitle">Eine kleine Java-Bibliothek für grafische Programmierung im 
+Informatikunterricht.</h2>
+
+## Projektidee
+
+Die **Zeichenmaschine** ist eine für den Informatikunterricht entwickelte
+Bibliothek, die unter anderem an [Processing](https://processing.org/) angelehnt
+ist. Die Bibliothek soll einige der üblichen Anfängerschwierigkeiten mit Java
+vereinfachen und grafische Ausgaben für Schülerinnen und Schüler im Unterricht
+leichter nutzbar machen.
+
+!!! warning
+
+	Das Projekt befindet sich noch in der Entwicklungsphase und auch wenn die 
+	aktuelle Version schon funktionsfähig ist und einen Großteil der angestrebten 
+	Funktionen enthält, ist noch keine stabile Version 1.0 erreicht. Vor allem 
+	am Umfang und konsistenten Design der APIs gilt es noch zu arbeiten und es 
+	können sich Änderungen ergeben.
+
+	Feedback und Vorschläge zu diesem Prozess (oder auch eine Beteiligung an der 
+	Entwicklung) können sehr gerne über [Github](https://github.com/jneug) oder 
+	[Mastodon](https://bildung.social/@ngb) an mich kommuniziert werden.
+	
+	(Gleiches gilt für diese Webseite zum Projekt.)
+
+## Dokumentation
+
+* [Schnellstart](schnellstart.md)
+* [Installation](installation.md)
+* [Javadoc]({{ javadoc() }})
+
+## Über die Zeichenmaschine
+
+Die _Zeichenmaschine_ ist aus dem Wunsch entstanden, nach einer Einführung in
+die Grundlagen der Programmiersprache Java mit Processing, einen Übergang zur
+objektorientierten Modellierung und Programmierung mit BlueJ zu leichter zu
+ermöglichen. Mit Processing kann zwar auch objektorientiert programmiert werden,
+aber mit Blick auf die Sekundarstufe II in NRW ist ein Wechsel zu einer
+generellen Programmierumgebung wie BlueJ wünschenswert.
+
+Die Motivation von Processing, schnell grafische Ergebnisse der eigenen
+Programme zu sehen, sollte aber für den Übergang erhalten bleiben. So ist eine
+kleine Bibliothek mit minimalen Abhängigkeiten entstanden, die an Processing
+angelehnt einfache Schnittstellen bereitstellte, um Programmen eine grafische
+Ausgabe zu ermöglichen, ohne viel "Boilerplate" Code schreiben zu müssen.
+
+Aus diesen Anfängen ist nach und nach eine umfassende Grafikbibliothek
+entstanden, die als _Zeichenmaschine_ veröffentlicht wurde.
+
+### Was die Zeichenmaschine nicht ist
+
+Die Bibliothek hat nicht den Anspruch, ein Konkurrent zu Processing oder
+anderen, seit Jahren etablierten und ausgereiften, Grafiksystemen zu sein. Vor
+allem ist die _Zeichenmaschine_ keine vollwertige Game Engine, die auf die
+Ausführung komplexer Spiele spezialisiert ist. Für diese Zwecke gibt es genügend
+Alternativen, von deren Nutzung gar nicht abgeraten werden soll.
+
+## Aufbau der Zeichenmaschine 
+
+!!! info
+
+	In der Zeichenmaschine werden bewusst nur englischsprachige Bezeichner für 
+	Klassen, Methoden und Variablen verwendet. Ausnahme sind einzelne Klassen,
+	die im Zusammnehang mit dem Namen der Bibliothek stehen, wie die
+	Hauptklasse `Zeichenmaschine`.
+

docs/installation.md

@@ -2,10 +2,9 @@
 
 Um ein einfaches Projekt mit der **Zeichenmaschine** aufzusetzen ist nicht mehr
 nötig, als
-die [JAR-Datei der aktuellen Version](https://github.com/jneug/zeichenmaschine/release/latest)
+die [JAR-Datei der aktuellen Version](https://github.com/jneug/zeichenmaschine/releases/latest)
 herunterzuladen und dem *Classpath* des Projekts hinzuzufügen. Beschreibungen
-für
-verschiedene Entwicklungsumgebungen sind hier aufgelistet.
+für verschiedene Entwicklungsumgebungen sind hier aufgelistet.
 
 ## Integration in Entwicklungsumgebungen
 

docs/schnellstart.md

@@ -23,7 +23,7 @@ werden.
 
 !!! note "main Methode"
 
-	Bei einigen Entwicklungsumgebungen muss noch eine `main` Methode erstellt 
+	Bei einigen Entwicklungsumgebungen muss noch eine `main` Methode erstellt
 	werden, um die Zeichenmaschine zu starten:
 
 	```java
@@ -40,11 +40,11 @@ an.
 
 	```java
 	public class Shapes extends Zeichenmaschine {
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 	}
 	```
 
@@ -57,7 +57,7 @@ erstellt und in einem Fenster mit dem Titel „Shapes“ angezeigt.
 
 ### Formen zeichnen
 
-Eine Zeichenmaschine hat verschiedene Möglichkeiten, Inhalte in das
+Eine Zeichenmaschine hat verschiedene Möglichkeiten Inhalte in das
 Zeichenfenster zu zeichnen. Um ein einfaches statisches Bild zu erzeugen,
 überschreiben wir die {{ jdl("schule.ngb.zm.Zeichenmaschine", "draw()",
 c=False) }} Methode.
@@ -66,20 +66,20 @@ c=False) }} Methode.
 
 	```java
 	public class Shapes extends Zeichenmaschine {
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 		@Override
 		public void draw() {
 			background.setColor(BLUE);
-	
+
 			drawing.setFillColor(255, 223, 34);
 			drawing.noStroke();
 			drawing.circle(400, 400, 100);
 		}
-	
+
 	}
 	```
 
@@ -101,19 +101,19 @@ die Zeichenfläche vor dem ersten Zeichnen vor.
 
 	```java
 	public class Shapes extends Zeichenmaschine {
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 		@Override
 		public void setup() {
 			background.setColor(BLUE);
-	
+
 			drawing.setFillColor(255, 223, 34);
 			drawing.noStroke();
 		}
-	
+
 		@Override
 		public void draw() {
 			for( int i = 0; i < 10; i++ ) {
@@ -124,7 +124,7 @@ die Zeichenfläche vor dem ersten Zeichnen vor.
 				);
 			}
 		}
-	
+
 	}
 	```
 
@@ -137,16 +137,16 @@ Im Beispiel setzen wir nun die Grundeinstellungen in der `setup()` Methode. In
 
 !!! tip ""
 
-	Mit {{ jdm("Constants", "canvasWidth") }} und 
-	{{ jdm("Constants", "canvasHeight") }} kannst du in der Zeichenmaschine 
+	Mit {{ jdm("Constants", "canvasWidth") }} und
+	{{ jdm("Constants", "canvasHeight") }} kannst du in der Zeichenmaschine
 	auf die aktuelle Größe der Zeichenfläche zugreifen.
-	{{ jdm("Constants", "random(int,int)") }} erzeugt eine Zufallszahl 
+	{{ jdm("Constants", "random(int,int)") }} erzeugt eine Zufallszahl
 	innerhalb der angegebenen Grenzen.
 
 ## Interaktionen mit der Maus: Whack-a-mole
 
 Mit der Zeichenmaschine lassen sich Interaktionen mit der Maus leicht umsetzen.
-Wor wollen das Beispielprogramm zu einem
+Wir wollen das Beispielprogramm zu einem
 [Whac-A-Mole](https://de.wikipedia.org/wiki/Whac-A-Mole) Spiel erweitern.
 
 Auf der Zeichenfläche wird nur noch ein gelber Kreis an einer zufälligen Stelle
@@ -169,28 +169,28 @@ zufälligen Werte initialisiert werden. Diese benutzen wir, um die `draw
 		private int moleX;
 
 		private int moleY;
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 		@Override
 		public void setup() {
 			background.setColor(BLUE);
-	
+
 			drawing.setFillColor(255, 223, 34);
 			drawing.noStroke();
 
 			moleX = random(50, canvasWidth - 50);
 			moleY = random(50, canvasHeight - 50);
 		}
-	
+
 		@Override
 		public void draw() {
 			drawing.clear();
 			drawing.circle(moleX, moleY, moleRadius);
 		}
-	
+
 	}
 	```
 
@@ -216,10 +216,10 @@ Pythagoras leicht selber berechnen. Die Zeichenmaschine kann uns diese Arbeit
 aber auch abnehmen und stellt eine Methode dafür bereit
 ({{ jdm("Constants", "distance(double,double,double,double)") }}).
 
-Um auf einen Mausklick zu reagieren, ergänzen wir die 
+Um auf einen Mausklick zu reagieren, ergänzen wir die
 {{ jdm("Zeichenmaschine", "mouseClicked()") }} Methode:
 
-```
+```java
 @Override
 public void mouseClicked() {
 	if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
@@ -240,22 +240,22 @@ public void mouseClicked() {
 		private int moleX;
 
 		private int moleY;
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 		@Override
 		public void setup() {
 			background.setColor(BLUE);
-	
+
 			drawing.setFillColor(255, 223, 34);
 			drawing.noStroke();
 
 			moleX = random(50, canvasWidth - 50);
 			moleY = random(50, canvasHeight - 50);
 		}
-	
+
 		@Override
 		public void draw() {
 			drawing.clear();
@@ -270,13 +270,13 @@ public void mouseClicked() {
 				redraw();
 			}
 		}
-	
+
 	}
 	```
 
 !!! warning ""
 
-	Der Aufruf von {{ jdm("Zeichenmaschine", "redraw()") }} zeichnet 
+	Der Aufruf von {{ jdm("Zeichenmaschine", "redraw()") }} zeichnet
 	die Zeichenfläche neu, indem die `draw()` Methode erneut aufgerufen wird.
 	Du solltest `draw()` niemals direkt aufrufen.
 
@@ -290,8 +290,8 @@ angeklickt wird.
 ## Ein paar Details zur Zeichenmaschine
 
 Die _Zeichenmaschine_ wurde stark von der kreativen Programmierumgebung
-[Processing](https://processing.org) inspiriert. Wenn Du Processing schon
-kennst, dann werden Dir einige der Konzepte der _Zeichenmaschine_ schon bekannt
+[Processing](https://processing.org) inspiriert. Wenn du Processing schon
+kennst, dann werden dir einige der Konzepte der _Zeichenmaschine_ schon bekannt
 vorkommen.
 
 ### Farben
@@ -300,7 +300,7 @@ Farben können auf verschiedene Weisen angegeben werden. Unser Beispiel nutzt
 bisher zwei Arten:
 
 1. Die einfachste Möglichkeit sind die _Farbkonstanten_
-   wie {{ jdm('Constants', 'BLUE') }} oder {{ jdm('Constants', 'RED') }}. Im 
+   wie {{ jdm('Constants', 'BLUE') }} oder {{ jdm('Constants', 'RED') }}. Im
    Beispiel setzen wir den Hintergrund auf die Farbe `BLUE`.
 2. Farben werden häufig im RGB-Farbraum definiert. Dazu wird jeweils der Rot-,
    Grün- und Blauanteil der Farbe als Wert zwischen 0 und 255 angegeben. Im
@@ -341,15 +341,15 @@ auf.
 </figure>
 
 Erstellst Du eine _Zeichenmaschine_ (beziehungsweise ein Objekt einer
-Unterklasse), dann wird zuerst die {{ jdm('Zeichenmaschine', 'setup()') }} 
-Methode ausgeführt. Danach folgt einmalig die 
+Unterklasse), dann wird zuerst die {{ jdm('Zeichenmaschine', 'setup()') }}
+Methode ausgeführt. Danach folgt einmalig die
 {{ jdm('Zeichenmaschine', 'draw()') }} Methode und dann endet das Hauptprogramm.
 
 Die Eingaben der Maus werden in einem parallelen Ablauf (einem _Thread_)
-abgefangen und daraufhin die {{ jdm('Zeichenmaschine', 'mouseClicked()') }} 
+abgefangen und daraufhin die {{ jdm('Zeichenmaschine', 'mouseClicked()') }}
 Methode aufgerufen. In unserem Programm prüfen wir, ob mit der Maus
-innerhalb des Kreises geklickt wurde und rufen dann 
-{{ jdm('Zeichenmaschine', 'redraw()') }} auf, woraufhin ein weiteres Mal 
+innerhalb des Kreises geklickt wurde und rufen dann
+{{ jdm('Zeichenmaschine', 'redraw()') }} auf, woraufhin ein weiteres Mal
 `draw()` ausgeführt wird.
 
 In _Processing_ wird dies der "statische" Modus genannt, weil das Programm nur
@@ -392,14 +392,14 @@ Sekunde aufgerufen wird. Normalerweise passiert dies genau 60-mal pro Sekunde.
 ### Lebenszeit eines Kreises
 
 Jeder Kreis soll drei Sekunden zu sehen sein. Daher fügen wir eine neue
-Objektvariable namens `moleTime` ein, die zunächst auf drei steht. Da wir auch
-Bruchteile von Skeunden abziehen wollen, wählen wir als Datentyp `double`:
+Objektvariable namens `moleTime` ein, die zunächst auf Drei steht. Da wir auch
+Bruchteile von Sekunden abziehen wollen, wählen wir als Datentyp `double`:
 
 ```Java
 private double moleTime=3.0;
 ```
 
-Der Parameter `delta`, der `update()` Methode ist der Zeitraum in Sekunden, seit
+Der Parameter `delta` der `update()` Methode ist der Zeitraum in Sekunden seit
 dem letzten Frame. Subtrahieren wir diesen Wert bei jedem Frame von `moleTime`,
 wird der Wert immer kleiner. Dann müssen wir nur noch prüfen, ob er kleiner Null
 ist und in dem Fall den Kreis auf eine neue Position springen lassen.
@@ -415,52 +415,52 @@ drawing.circle(moleX,moleY,moleRadius*(moleTime/3.0));
 
 	```Java
 	import schule.ngb.zm.Zeichenmaschine;
-	
+
 	public class Shapes extends Zeichenmaschine {
-	
+
 		private int moleRadius = 20;
-	
+
 		private int moleX;
-	
+
 		private int moleY;
-	
+
 		private double moleTime;
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 		@Override
 		public void setup() {
 			background.setColor(BLUE);
-	
+
 			drawing.setFillColor(255, 223, 34);
 			drawing.noStroke();
-	
+
 			randomizeMole();
 		}
-	
+
 		private void randomizeMole() {
 			moleX = random(moleRadius*2, canvasWidth - moleRadius*2);
 			moleY = random(moleRadius*2, canvasHeight - moleRadius*2);
 			moleTime = 3.0;
 		}
-	
+
 		@Override
 		public void update( double delta ) {
 			moleTime -= delta;
-	
+
 			if( moleTime <= 0 ) {
 				randomizeMole();
 			}
 		}
-	
+
 		@Override
 		public void draw() {
 			drawing.clear();
 			drawing.circle(moleX, moleY, moleRadius * (moleTime / 3.0));
 		}
-	
+
 		@Override
 		public void mouseClicked() {
 			if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
@@ -468,11 +468,11 @@ drawing.circle(moleX,moleY,moleRadius*(moleTime/3.0));
 				redraw();
 			}
 		}
-	
+
 		public static void main( String[] args ) {
 			new Shapes();
 		}
-	
+
 	}
 	```
 
@@ -483,21 +483,21 @@ drawing.circle(moleX,moleY,moleRadius*(moleTime/3.0));
 !!! tip ""
 
 	Der Maulwurf muss mittlerweile an drei verschiedenen Stellen im Programm
-	auf eine zufällige Position gesetzt werden (am Anfang, wenn er angeklickt 
+	auf eine zufällige Position gesetzt werden (am Anfang, wenn er angeklickt
 	wurde und wenn die drei Sekunden abgelaufen sind). Daher wurde das Versetzen
-	in eine eigene Methode `randomizeMole()` ausgelagert. 
+	in eine eigene Methode `randomizeMole()` ausgelagert.
 
 ### Punktezähler
 
-Zum Schluss wollen wir noch bei jedem Treffer mit der Maus die Punkte Zählen und
+Zum Schluss wollen wir noch bei jedem Treffer mit der Maus die Punkte zählen und
 als Text auf die Zeichenfläche schreiben.
 
 Dazu ergänzen wir eine weitere Objektvariable `score`, die in `mouseClicked()`
 erhöht wird, falls der Kreis getroffen wurde.
 
-Um den Punktestand anzuzeigen ergänzen wir in `draw()` einen Aufruf von 
-{{ jdl('layers.DrawingLayer', 'text(java.lang.String,double,double,schule.ngb.zm.Options.Direction)') }} 
-mit dem  Inhalt von `score` und den Koordinaten, an denen der Text gezeigt 
+Um den Punktestand anzuzeigen ergänzen wir in `draw()` einen Aufruf von
+{{ jdl('layers.DrawingLayer', 'text(java.lang.String,double,double,schule.ngb.zm.Options.Direction)') }}
+mit dem  Inhalt von `score` und den Koordinaten, an denen der Text gezeigt
 werden soll.
 Die Zeichenebene zeichnet im Moment alle Formen und Text ausgehend vom Zentrum
 der Form. Damit der Text 10 Pixel vom Rand entfernt links oben angezeigt wird,
@@ -518,59 +518,59 @@ drawing.setFillColor(BLACK);
 
 	```Java
 	import schule.ngb.zm.Zeichenmaschine;
-	
+
 	public class Shapes extends Zeichenmaschine {
-	
+
 		private int moleRadius = 20;
-	
+
 		private int moleX;
-	
+
 		private int moleY;
-	
+
 		private double moleTime;
-	
+
 		private int score = 0;
-	
+
 		public Shapes() {
 			super(800, 800, "Shapes");
 		}
-	
+
 		@Override
 		public void setup() {
 			background.setColor(BLUE);
-	
+
 			drawing.noStroke();
 			drawing.setFontSize(24);
-	
+
 			randomizeMole();
 		}
-	
+
 		private void randomizeMole() {
 			moleX = random(moleRadius*2, canvasWidth - moleRadius*2);
 			moleY = random(moleRadius*2, canvasHeight - moleRadius*2);
 			moleTime = 3.0;
 		}
-	
+
 		@Override
 		public void update( double delta ) {
 			moleTime -= delta;
-	
+
 			if( moleTime <= 0 ) {
 				randomizeMole();
 			}
 		}
-	
+
 		@Override
 		public void draw() {
 			drawing.clear();
-	
+
 			drawing.setFillColor(255, 223, 34);
 			drawing.circle(moleX, moleY, moleRadius * (moleTime / 3.0));
-	
+
 			drawing.setFillColor(BLACK);
 			drawing.text("Punkte: " + score, 10, 10, NORTHWEST);
 		}
-	
+
 		@Override
 		public void mouseClicked() {
 			if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
@@ -579,28 +579,28 @@ drawing.setFillColor(BLACK);
 				redraw();
 			}
 		}
-	
+
 		public static void main( String[] args ) {
 			new Shapes();
 		}
-	
+
 	}
 	```
 
 ## Wie es weitergehen kann
 
-In diesem Schnellstart-Tutorial hast Du die Grundlagen der _Zeichenmaschine_
-gelernt. Um weiterzumachen, kannst Du versuchen, das Whack-a-mole Spiel um diese
+In diesem Schnellstart-Tutorial hast du die Grundlagen der _Zeichenmaschine_
+gelernt. Um weiterzumachen, kannst du versuchen, das Whack-a-mole Spiel um diese
 Funktionen zu erweitern:
 
 - Mehrere "Maulwürfe" gleichzeitig.
 - Unterschiedliche Zeiten pro Maulwurf.
 
-Wenn Du mehr über die Möglichkeiten lernen möchtest, die Dir die
-_Zeichenmaschine_ bereitstellt, kannst Du Dir die weiteren Tutorials in dieser
+Wenn du mehr über die Möglichkeiten lernen möchtest, die dir die
+_Zeichenmaschine_ bereitstellt, kannst du dir die weiteren Tutorials in dieser
 Dokumentation ansehen. Ein guter Startpunkt ist das
 [Aquarium](tutorials/aquarium/aquarium1.md).
 
-Viele verschiedene Beispiele, ohne detailliertes Tutorial, findest Du in der
+Viele verschiedene Beispiele, ohne detailliertes Tutorial, findest du in der
 Kategorie Beispiele und auf GitHub im Repository
 [jneug/zeichenmaschine-examples](https://github.com/jneug/zeichenmaschine-examples).

mkdocs.yml

@@ -8,7 +8,7 @@ site_dir: build/docs/site
 
 theme:
     name: material
-    custom_dir: docs/home_override/
+    # custom_dir: docs/home_override/
     language: de
     logo: assets/icon_64.png
     favicon: assets/icon_32.png
@@ -37,7 +37,7 @@ extra_css:
     - assets/zmstyles.css
 
 nav:
-    -   Einführung: einfuehrung.md
+    -   Einführung: index.md
     -   Schnellstart: schnellstart.md
     -   Installation: installation.md
     -   Tutorials:

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

@@ -34,6 +34,11 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 	 */
 	protected Options.StrokeType strokeType = SOLID;
 
+	/**
+	 * Die Art der Kantenverbindungen von Linien.
+	 */
+	protected Options.StrokeJoin strokeJoin = MITER;
+
 	/**
 	 * Cache für den aktuellen {@code Stroke} der Kontur. Wird nach Änderung
 	 * einer der Kontureigenschaften auf {@code null} gesetzt und beim nächsten
@@ -53,6 +58,7 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 	 */
 	protected MultipleGradientPaint fill = null;
 
+	// TODO: Add TexturePaint fill (https://docs.oracle.com/javase/8/docs//api/java/awt/TexturePaint.html)
 
 	// Implementierung Drawable Interface
 
@@ -154,7 +160,7 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 	@Override
 	public Stroke getStroke() {
 		if( stroke == null ) {
-			stroke = Strokeable.createStroke(strokeType, strokeWeight);
+			stroke = Strokeable.createStroke(strokeType, strokeWeight, strokeJoin);
 		}
 		return stroke;
 	}
@@ -191,4 +197,15 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 		this.stroke = null;
 	}
 
+	@Override
+	public Options.StrokeJoin getStrokeJoin() {
+		return strokeJoin;
+	}
+
+	@Override
+	public void setStrokeJoin( Options.StrokeJoin join ) {
+		strokeJoin = join;
+		this.stroke = null;
+	}
+
 }

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

@@ -576,6 +576,18 @@ public class Color implements Paint {
 		}
 	}
 
+	public double compare( Color color ) {
+		double maxDist = 764.8333151739665;
+
+		// see: https://www.compuphase.com/cmetric.htm
+		long rmean = (getRed() + color.getRed()) / 2;
+		long r = getRed() - color.getRed();
+		long g = getGreen() - color.getGreen();
+		long b = getBlue() - color.getBlue();
+
+		return 1.0 - (Math.sqrt((((512+rmean)*r*r)>>8) + 4*g*g + (((767-rmean)*b*b)>>8)) / maxDist);
+	}
+
 	/**
 	 * Prüft, ob ein anderes Objekt zu diesem gleich ist.
 	 * <p>

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

@@ -11,6 +11,7 @@ import java.awt.event.MouseEvent;
 import java.awt.image.BufferedImage;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import java.util.Random;
 import java.util.function.DoubleUnaryOperator;
 
@@ -67,7 +68,7 @@ public class Constants {
 	/**
 	 * Patchversion der Zeichenmaschine.
 	 */
-	public static final int APP_VERSION_REV = 32;
+	public static final int APP_VERSION_REV = 35;
 
 	/**
 	 * Version der Zeichenmaschine als Text-String.
@@ -170,6 +171,21 @@ public class Constants {
 	 */
 	public static final Options.StrokeType DOTTED = Options.StrokeType.DOTTED;
 
+	/**
+	 * Option für abgerundete Kantenverbindungen von Konturen und Linien.
+	 */
+	public static final Options.StrokeJoin ROUND = Options.StrokeJoin.ROUND;
+
+	/**
+	 * Option für abgeschnittene Kantenverbindungen von Konturen und Linien.
+	 */
+	public static final Options.StrokeJoin BEVEL = Options.StrokeJoin.BEVEL;
+
+	/**
+	 * Option für eckige Kantenverbindungen von Konturen und Linien.
+	 */
+	public static final Options.StrokeJoin MITER = Options.StrokeJoin.MITER;
+
 	/**
 	 * Option für Pfeile mit Strichen als Kopf.
 	 */
@@ -1268,7 +1284,7 @@ public class Constants {
 	 *
 	 * @return Die {@code Random}-Instanz.
 	 */
-	private static Random getRandom() {
+	public static Random getRandom() {
 		if( random == null ) {
 			random = new Random();
 		}
@@ -1389,26 +1405,6 @@ public class Constants {
 		return getRandom().nextGaussian();
 	}
 
-	/**
-	 * Wählt ein zufälliges Element aus dem Array aus.
-	 *
-	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
-	 * @return Ein zufälliges Element aus dem Array.
-	 */
-	public static final int choice( int... values ) {
-		return values[random(0, values.length - 1)];
-	}
-
-	/**
-	 * Wählt ein zufälliges Element aus dem Array aus.
-	 *
-	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
-	 * @return Ein zufälliges Element aus dem Array.
-	 */
-	public static final double choice( double... values ) {
-		return values[random(0, values.length - 1)];
-	}
-
 	/**
 	 * Wählt ein zufälliges Element aus dem Array aus.
 	 *
@@ -1571,6 +1567,18 @@ public class Constants {
 		return valueList.toArray(values);
 	}
 
+	/**
+	 * Bringt die Werte im Array in eine zufällige Reihenfolge.
+	 *
+	 * @param values Ein Array mit Werte, die gemischt werden sollen.
+	 * @param <T> Datentyp der Elemente.
+	 * @return Das Array in zufälliger Reihenfolge.
+	 */
+	public static final <T> List<T> shuffle( List<T> values ) {
+		Collections.shuffle(values, random);
+		return values;
+	}
+
 	/**
 	 * Geteilte {@code Noise}-Instanz zur Erzeugung von Perlin-Noise.
 	 */

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

@@ -1,5 +1,6 @@
 package schule.ngb.zm;
 
+import java.awt.BasicStroke;
 import java.awt.geom.Arc2D;
 
 /**
@@ -31,6 +32,36 @@ public final class Options {
 		DOTTED
 	}
 
+	/**
+	 * Linienstile für Konturlinien.
+	 */
+	public enum StrokeJoin {
+
+		/**
+		 * Abgerundete Verbindungen.
+		 */
+		ROUND(BasicStroke.JOIN_ROUND),
+
+		/**
+		 * Abgeschnittene Verbindungen.
+		 */
+		BEVEL(BasicStroke.JOIN_BEVEL),
+
+		/**
+		 * Eckige Verbindungen.
+		 */
+		MITER(BasicStroke.JOIN_MITER);
+
+		/**
+		 * Der entsprechende Wert der Konstanten in {@link java.awt}
+		 */
+		public final int awt_type;
+
+		StrokeJoin( int type ) {
+			awt_type = type;
+		}
+	}
+
 	/**
 	 * Stile für Pfeilspitzen.
 	 */

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

@@ -174,7 +174,7 @@ public interface Strokeable extends Drawable {
 	 * @param weight Die Dicke der Konturlinie.
 	 */
 	default void setStrokeWeight( double weight ) {
-		setStroke(createStroke(getStrokeType(), weight));
+		setStroke(createStroke(getStrokeType(), weight, getStrokeJoin()));
 	}
 
 	/**
@@ -193,7 +193,26 @@ public interface Strokeable extends Drawable {
 	 * @see Options.StrokeType
 	 */
 	default void setStrokeType( Options.StrokeType type ) {
-		setStroke(createStroke(type, getStrokeWeight()));
+		setStroke(createStroke(type, getStrokeWeight(), getStrokeJoin()));
+	}
+
+	/**
+	 * Gibt die Art der Konturverbindungen zurück.
+	 *
+	 * @return Die aktuelle Art der Konturverbindungen.
+	 * @see Options.StrokeJoin
+	 */
+	Options.StrokeJoin getStrokeJoin();
+
+	/**
+	 * Setzt den Typ der Konturverbindungen. Erlaubte Werte sind {@link Constants#ROUND},
+	 * {@link Constants#MITER} und {@link Constants#BEVEL}.
+	 *
+	 * @param join Eine der möglichen Konturverbindungen.
+	 * @see Options.StrokeJoin
+	 */
+	default void setStrokeJoin( Options.StrokeJoin join ) {
+		setStroke(createStroke(getStrokeType(), getStrokeWeight(), join));
 	}
 
 	/**
@@ -205,26 +224,26 @@ public interface Strokeable extends Drawable {
 	 * @param strokeWeight
 	 * @return Ein {@code Stroke} mit den passenden Kontureigenschaften.
 	 */
-	static Stroke createStroke( Options.StrokeType strokeType, double strokeWeight ) {
+	static Stroke createStroke( Options.StrokeType strokeType, double strokeWeight, Options.StrokeJoin strokeJoin ) {
 		switch( strokeType ) {
 			case DOTTED:
 				return new BasicStroke(
 					(float) strokeWeight,
 					BasicStroke.CAP_ROUND,
-					BasicStroke.JOIN_ROUND,
+					strokeJoin.awt_type,
 					10.0f, new float[]{1.0f, 5.0f}, 0.0f);
 			case DASHED:
 				return new BasicStroke(
 					(float) strokeWeight,
 					BasicStroke.CAP_ROUND,
-					BasicStroke.JOIN_ROUND,
+					strokeJoin.awt_type,
 					10.0f, new float[]{5.0f}, 0.0f);
 			case SOLID:
 			default:
 				return new BasicStroke(
 					(float) strokeWeight,
 					BasicStroke.CAP_ROUND,
-					BasicStroke.JOIN_ROUND);
+					strokeJoin.awt_type);
 		}
 	}
 

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

@@ -191,6 +191,22 @@ public class Vector extends Point2D.Double {
 		return new Vector(x, y);
 	}
 
+	public int getIntX() {
+		return (int)this.x;
+	}
+
+	public int getRoundedX() {
+		return (int)Math.round(this.x);
+	}
+
+	public int getIntY() {
+		return (int)this.y;
+	}
+
+	public int getRoundedY() {
+		return (int)Math.round(this.y);
+	}
+
 	/**
 	 * Setzt die Komponenten dieses Vektors neu.
 	 *

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

@@ -2,6 +2,7 @@ package schule.ngb.zm;
 
 import schule.ngb.zm.util.Log;
 import schule.ngb.zm.util.Validator;
+import schule.ngb.zm.util.io.ImageLoader;
 
 import javax.imageio.ImageIO;
 import javax.swing.*;
@@ -10,6 +11,7 @@ import java.awt.event.KeyAdapter;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.ArrayList;
 
@@ -26,7 +28,7 @@ public class Zeichenfenster extends JFrame {
 	/**
 	 * Setzt das Look and Feel auf den Standard des Systems.
 	 * <p>
-	 * Sollte einmalig vor erstellen des erstyen Programmfensters aufgerufen
+	 * Sollte einmalig vor Erstellen des ersten Programmfensters aufgerufen
 	 * werden.
 	 */
 	public static final void setLookAndFeel() {
@@ -174,12 +176,14 @@ public class Zeichenfenster extends JFrame {
 		// Das Icon des Fensters ändern
 		try {
 			if( Zeichenmaschine.MACOS ) {
-				URL iconUrl = Zeichenmaschine.class.getResource("icon_512.png");
-				if( iconUrl != null ) {
-					Image icon = ImageIO.read(iconUrl);
+				InputStream iconStream = this.getClass().getResourceAsStream("icon_512.png");
+				if( iconStream != null ) {
+					Image icon = ImageIO.read(iconStream);
 					// Dock Icon in macOS setzen
 					Taskbar taskbar = Taskbar.getTaskbar();
 					taskbar.setIconImage(icon);
+				} else {
+					LOG.warn("Could not load dock-icon");
 				}
 			} else {
 				ArrayList<Image> icons = new ArrayList<>(4);
@@ -190,7 +194,11 @@ public class Zeichenfenster extends JFrame {
 					}
 				}
 
-				this.setIconImages(icons);
+				if( icons.isEmpty() ) {
+					LOG.warn("Could not load dock-icon");
+				} else {
+					this.setIconImages(icons);
+				}
 			}
 		} catch( IllegalArgumentException | IOException e ) {
 			LOG.warn("Could not load image icons: %s", e.getMessage());

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

@@ -94,7 +94,7 @@ public class Zeichenmaschine extends Constants {
 	 */
 	private boolean running;
 
-	private boolean terminateImediately = false;
+	private boolean terminateImmediately = false;
 
 	/**
 	 * Ob die ZM nach dem nächsten Frame pausiert werden soll.
@@ -545,7 +545,7 @@ public class Zeichenmaschine extends Constants {
 
 		if( running ) {
 			running = false;
-			terminateImediately = true;
+			terminateImmediately = true;
 			quitAfterShutdown = true;
 			mainThread.interrupt();
 		} else {
@@ -769,6 +769,23 @@ public class Zeichenmaschine extends Constants {
 		framesPerSecond = framesPerSecondInternal;
 	}
 
+	/**
+	 * Erstellt aus dem aktuellen Inhalt der {@link Zeichenleinwand} ein neues
+	 * {@link BufferedImage}.
+	 */
+	public final BufferedImage getImage() {
+		BufferedImage img = ImageLoader.createImage(canvas.getWidth(), canvas.getHeight());
+
+		Graphics2D g = img.createGraphics();
+		// TODO: Transparente Hintergründe beim Speichern von png erlauben
+		g.setColor(DEFAULT_BACKGROUND.getJavaColor());
+		g.fillRect(0, 0, img.getWidth(), img.getHeight());
+		canvas.draw(g);
+		g.dispose();
+
+		return img;
+	}
+
 	/**
 	 * Speichert den aktuellen Inhalt der {@link Zeichenleinwand} in einer
 	 * Bilddatei auf der Festplatte. Zur Auswahl der Zieldatei wird dem Nutzer
@@ -794,23 +811,15 @@ public class Zeichenmaschine extends Constants {
 	 * Bilddatei im angegebenen Dateipfad auf der Festplatte.
 	 */
 	public final void saveImage( String filepath ) {
-		BufferedImage img = ImageLoader.createImage(canvas.getWidth(), canvas.getHeight());
-
-		Graphics2D g = img.createGraphics();
-		g.setColor(DEFAULT_BACKGROUND.getJavaColor());
-		g.fillRect(0, 0, img.getWidth(), img.getHeight());
-		canvas.draw(g);
-		g.dispose();
-
 		try {
-			ImageLoader.saveImage(img, new File(filepath), true);
+			ImageLoader.saveImage(getImage(), new File(filepath), true);
 		} catch( IOException ex ) {
 			ex.printStackTrace();
 		}
 	}
 
 	/**
-	 * Erstellt eine Momentanaufnahme des aktuellen Inhalts der
+	 * Erstellt eine Momentaufnahme des aktuellen Inhalts der
 	 * {@link Zeichenleinwand} und erstellt daraus eine
 	 * {@link ImageLayer Bildebene}. Die Ebene wird automatisch der
 	 * {@link Zeichenleinwand} vor dem {@link #background} hinzugefügt.
@@ -1177,6 +1186,9 @@ public class Zeichenmaschine extends Constants {
 				//saveMousePosition(evt);
 				mouseMoved(evt);
 				break;
+			case MouseEvent.MOUSE_WHEEL:
+				mouseWheelMoved(evt);
+				break;
 		}
 	}
 
@@ -1220,6 +1232,14 @@ public class Zeichenmaschine extends Constants {
 		// Intentionally left blank
 	}
 
+	public void mouseWheelMoved( MouseEvent e ) {
+		mouseMoved();
+	}
+
+	public void mouseWheelMoved() {
+		// Intentionally left blank
+	}
+
 	private void saveMousePosition( MouseEvent event ) {
 		if( mouseEvent != null && event.getComponent() == canvas ) {
 			pmouseX = mouseX;
@@ -1387,7 +1407,7 @@ public class Zeichenmaschine extends Constants {
 
 						if( Thread.interrupted() ) {
 							running = false;
-							terminateImediately = true;
+							terminateImmediately = true;
 							break;
 						}
 					}
@@ -1443,7 +1463,7 @@ public class Zeichenmaschine extends Constants {
 			}
 			state = Options.AppState.STOPPED;
 			// Shutdown the updateThread
-			while( !terminateImediately && updateThreadExecutor.isRunning() ) {
+			while( !terminateImmediately && updateThreadExecutor.isRunning() ) {
 				Thread.yield();
 			}
 			updateThreadExecutor.shutdownNow();

src/main/java/schule/ngb/zm/anim/Animation.java

@@ -50,7 +50,7 @@ public abstract class Animation<T> extends Constants implements Updatable {
 	}
 
 	public void setEasing( DoubleUnaryOperator pEasing ) {
-		this.easing = pEasing;
+		this.easing = Validator.requireNotNull(pEasing, "easing");
 	}
 
 	public abstract T getAnimationTarget();
@@ -61,7 +61,7 @@ public abstract class Animation<T> extends Constants implements Updatable {
 		running = true;
 		finished = false;
 		animate(easing.applyAsDouble(0.0));
-		initializeEventDispatcher().dispatchEvent("start", this);
+		dispatchEvent("start");
 	}
 
 	public final void stop() {
@@ -70,7 +70,7 @@ public abstract class Animation<T> extends Constants implements Updatable {
 		animate(easing.applyAsDouble((double) elapsedTime / (double) runtime));
 		this.finish();
 		finished = true;
-		initializeEventDispatcher().dispatchEvent("stop", this);
+		dispatchEvent("stop");
 	}
 
 	public void initialize() {
@@ -100,10 +100,9 @@ public abstract class Animation<T> extends Constants implements Updatable {
 
 		double t = (double) elapsedTime / (double) runtime;
 		if( t >= 1.0 ) {
-			running = false;
 			stop();
 		} else {
-			animate(easing.applyAsDouble(t));
+			animate(getEasing().applyAsDouble(t));
 		}
 	}
 
@@ -118,7 +117,7 @@ public abstract class Animation<T> extends Constants implements Updatable {
 	 * e = Constants.limit(e, 0, 1);
 	 * </code></pre>
 	 *
-	 * @param e Fortschritt der Animation nachdem die Easingfunktion angewandt
+	 * @param e Fortschritt der Animation, nachdem die Easing-Funktion angewandt
 	 * 	wurde.
 	 */
 	public abstract void animate( double e );
@@ -134,6 +133,12 @@ public abstract class Animation<T> extends Constants implements Updatable {
 		return eventDispatcher;
 	}
 
+	private void dispatchEvent( String type ) {
+		if( eventDispatcher != null ) {
+			eventDispatcher.dispatchEvent(type, this);
+		}
+	}
+
 	public void addListener( AnimationListener listener ) {
 		initializeEventDispatcher().addListener(listener);
 	}

src/main/java/schule/ngb/zm/anim/AnimationFacade.java

@@ -4,9 +4,15 @@ import schule.ngb.zm.util.Validator;
 
 import java.util.function.DoubleUnaryOperator;
 
+/**
+ * Eine Wrapper Animation, um die Werte einer anderen Animation (Laufzeit, Easing) zu überschrieben,
+ * ohne die Werte der Originalanimation zu verändern.
+ *
+ * @param <S> Art des Animierten Objektes.
+ */
 public class AnimationFacade<S> extends Animation<S> {
 
-	private Animation<S> anim;
+	private final Animation<S> anim;
 
 	public AnimationFacade( Animation<S> anim, int runtime, DoubleUnaryOperator easing ) {
 		super(runtime, easing);

src/main/java/schule/ngb/zm/anim/AnimationGroup.java

@@ -1,22 +1,28 @@
 package schule.ngb.zm.anim;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.function.DoubleUnaryOperator;
 
+// TODO: (ngb) Maybe use AnimationFacade to override runtime?
 @SuppressWarnings( "unused" )
 public class AnimationGroup<T> extends Animation<T> {
 
-	List<Animation<T>> anims;
+	private final List<Animation<T>> anims;
 
-	private boolean overrideEasing = false;
+	private final boolean overrideEasing;
 
 	private int overrideRuntime = -1;
 
-	private int lag = 0;
+	private final int lag;
 
 	private int active = 0;
 
+	public AnimationGroup( Animation<T>... anims ) {
+		this(0, -1, null, Arrays.asList(anims));
+	}
+
 	public AnimationGroup( Collection<Animation<T>> anims ) {
 		this(0, -1, null, anims);
 	}
@@ -42,6 +48,8 @@ public class AnimationGroup<T> extends Animation<T> {
 		if( easing != null ) {
 			this.easing = easing;
 			overrideEasing = true;
+		} else {
+			overrideEasing = false;
 		}
 
 		if( runtime > 0 ) {
@@ -64,52 +72,110 @@ public class AnimationGroup<T> extends Animation<T> {
 				return anim.getAnimationTarget();
 			}
 		}
-		return anims.get(anims.size() - 1).getAnimationTarget();
+		if( this.finished ) {
+			return anims.get(anims.size() - 1).getAnimationTarget();
+		} else {
+			return anims.get(0).getAnimationTarget();
+		}
 	}
 
 	@Override
-	public void update( double delta ) {
-		elapsedTime += (int) (delta * 1000);
-		// Animation is done. Stop all Animations.
-		if( elapsedTime > runtime ) {
-			for( int i = 0; i < anims.size(); i++ ) {
-				if( anims.get(i).isActive() ) {
-					anims.get(i).elapsedTime = anims.get(i).runtime;
-					anims.get(i).stop();
-				}
+	public DoubleUnaryOperator getEasing() {
+		for( Animation<T> anim : anims ) {
+			if( anim.isActive() ) {
+				return anim.getEasing();
 			}
-			running = false;
-			this.stop();
 		}
-
-		while( active < anims.size() && elapsedTime >= active * lag ) {
-			anims.get(active).start();
-			active += 1;
+		if( this.finished ) {
+			return anims.get(anims.size() - 1).getEasing();
+		} else {
+			return anims.get(0).getEasing();
 		}
+	}
 
-		for( int i = 0; i < active; i++ ) {
-			double t = 0.0;
-			if( overrideRuntime > 0 ) {
-				t = (double) (elapsedTime - i*lag) / (double) overrideRuntime;
-			} else {
-				t = (double) (elapsedTime - i*lag) / (double) anims.get(i).getRuntime();
-			}
+//	@Override
+//	public void update( double delta ) {
+//		elapsedTime += (int) (delta * 1000);
+//
+//		// Animation is done. Stop all Animations.
+//		if( elapsedTime > runtime ) {
+//			for( int i = 0; i < anims.size(); i++ ) {
+//				if( anims.get(i).isActive() ) {
+//					anims.get(i).elapsedTime = anims.get(i).runtime;
+//					anims.get(i).stop();
+//				}
+//			}
+//			elapsedTime = runtime;
+//			running = false;
+//			this.stop();
+//		}
+//
+//		while( active < anims.size() && elapsedTime >= active * lag ) {
+//			anims.get(active).start();
+//			active += 1;
+//		}
+//
+//		for( int i = 0; i < active; i++ ) {
+//			double t = 0.0;
+//			if( overrideRuntime > 0 ) {
+//				t = (double) (elapsedTime - i*lag) / (double) overrideRuntime;
+//			} else {
+//				t = (double) (elapsedTime - i*lag) / (double) anims.get(i).getRuntime();
+//			}
+//
+//			if( t >= 1.0 ) {
+//				anims.get(i).elapsedTime = anims.get(i).runtime;
+//				anims.get(i).stop();
+//			} else {
+//				double e = overrideEasing ?
+//					easing.applyAsDouble(t) :
+//					anims.get(i).easing.applyAsDouble(t);
+//
+//				anims.get(i).animate(e);
+//			}
+//		}
+//	}
 
-			if( t >= 1.0 ) {
-				anims.get(i).elapsedTime = anims.get(i).runtime;
-				anims.get(i).stop();
-			} else {
-				double e = overrideEasing ?
-					easing.applyAsDouble(t) :
-					anims.get(i).easing.applyAsDouble(t);
 
-				anims.get(i).animate(e);
+	@Override
+	public void finish() {
+		for( Animation<T> anim : anims ) {
+			if( anim.isActive() ) {
+				anim.elapsedTime = anim.runtime;
+				anim.stop();
 			}
 		}
 	}
 
 	@Override
 	public void animate( double e ) {
+		while( active < anims.size() && elapsedTime >= active * lag ) {
+			anims.get(active).start();
+			active += 1;
+		}
+
+		for( int i = 0; i < active; i++ ) {
+			Animation<T> curAnim = anims.get(i);
+
+			double curRuntime = curAnim.getRuntime();
+			if( overrideRuntime > 0 ) {
+				curRuntime = overrideRuntime;
+			}
+
+			double t = (double) (elapsedTime - i * lag) / (double) curRuntime;
+			if( t >= 1.0 ) {
+				curAnim.elapsedTime = curAnim.getRuntime();
+				curAnim.stop();
+			} else {
+				e = overrideEasing ?
+					easing.applyAsDouble(t) :
+					curAnim.easing.applyAsDouble(t);
+
+				curAnim.elapsedTime = (elapsedTime - i * lag);
+				curAnim.animate(e);
+			}
+		}
+
 	}
 
 }

src/main/java/schule/ngb/zm/anim/AnimationSequence.java

@@ -0,0 +1,144 @@
+package schule.ngb.zm.anim;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.DoubleUnaryOperator;
+
+/**
+ * Führt eine Liste von Animationen nacheinander aus. Jede Animation startet direkt nachdem die
+ * davor geendet ist. Optional kann zwischen dem Ende einer und dem Start der nächsten Animation
+ * ein
+ * <var>lag</var> eingefügt werden.
+ *
+ * @param <T> Die Art des animierten Objektes.
+ */
+@SuppressWarnings( "unused" )
+public class AnimationSequence<T> extends Animation<T> {
+
+	private final List<Animation<T>> anims;
+
+	private final int lag;
+
+	private int currentAnimationIndex = -1, currentStart = -1, nextStart = -1;
+
+	@SafeVarargs
+	public AnimationSequence( Animation<T>... anims ) {
+		this(0, Arrays.asList(anims));
+	}
+
+	public AnimationSequence( Collection<Animation<T>> anims ) {
+		this(0, anims);
+	}
+
+	public AnimationSequence( int lag, Collection<Animation<T>> anims ) {
+		super(Easing::linear);
+
+		this.anims = List.copyOf(anims);
+		this.lag = lag;
+
+		this.runtime = (anims.size() - 1) * lag + anims.stream().mapToInt(Animation::getRuntime).sum();
+	}
+
+	@Override
+	public T getAnimationTarget() {
+		for( Animation<T> anim : anims ) {
+			if( anim.isActive() ) {
+				return anim.getAnimationTarget();
+			}
+		}
+		if( this.finished ) {
+			return anims.get(anims.size() - 1).getAnimationTarget();
+		} else {
+			return anims.get(0).getAnimationTarget();
+		}
+	}
+
+	@Override
+	public DoubleUnaryOperator getEasing() {
+		for( Animation<T> anim : anims ) {
+			if( anim.isActive() ) {
+				return anim.getEasing();
+			}
+		}
+		if( this.finished ) {
+			return anims.get(anims.size() - 1).getEasing();
+		} else {
+			return anims.get(0).getEasing();
+		}
+	}
+
+//	@Override
+//	public void update( double delta ) {
+//		elapsedTime += (int) (delta * 1000);
+//
+//		// Animation is done. Stop all Animations.
+//		if( elapsedTime > runtime ) {
+//			for( int i = 0; i < anims.size(); i++ ) {
+//				if( anims.get(i).isActive() ) {
+//					anims.get(i).elapsedTime = anims.get(i).runtime;
+//					anims.get(i).stop();
+//				}
+//			}
+//			elapsedTime = runtime;
+//			running = false;
+//			this.stop();
+//		}
+//
+//		Animation<T> curAnim = null;
+//		if( elapsedTime > nextStart ) {
+//			currentAnimation += 1;
+//			curAnim = anims.get(currentAnimation);
+//			currentStart = nextStart;
+//			nextStart += lag + curAnim.getRuntime();
+//			curAnim.start();
+//		} else {
+//			curAnim = anims.get(currentAnimation);
+//		}
+//
+//		// Calculate delta for current animation
+//		double t = (double) (elapsedTime - currentStart) / (double) curAnim.getRuntime();
+//		if( t >= 1.0 ) {
+//			curAnim.elapsedTime = curAnim.runtime;
+//			curAnim.stop();
+//		} else {
+//			curAnim.animate(curAnim.easing.applyAsDouble(t));
+//		}
+//	}
+
+
+	@Override
+	public void finish() {
+		for( Animation<T> anim : anims ) {
+			if( anim.isActive() ) {
+				anim.elapsedTime = anim.runtime;
+				anim.stop();
+			}
+		}
+	}
+
+	@Override
+	public void animate( double e ) {
+		Animation<T> curAnim = null;
+		if( running && elapsedTime > nextStart ) {
+			currentAnimationIndex += 1;
+			curAnim = anims.get(currentAnimationIndex);
+			currentStart = nextStart;
+			nextStart += lag + curAnim.getRuntime();
+			curAnim.start();
+		} else {
+			curAnim = anims.get(currentAnimationIndex);
+		}
+
+		// Calculate delta for current animation
+		double t = (double) (elapsedTime - currentStart) / (double) curAnim.getRuntime();
+		if( t >= 1.0 ) {
+			curAnim.elapsedTime = curAnim.runtime;
+			curAnim.stop();
+		} else {
+			curAnim.elapsedTime = (elapsedTime - currentStart);
+			curAnim.animate(curAnim.easing.applyAsDouble(t));
+		}
+	}
+
+}

src/main/java/schule/ngb/zm/anim/CircleAnimation.java

@@ -7,33 +7,87 @@ import schule.ngb.zm.shapes.Shape;
 
 import java.util.function.DoubleUnaryOperator;
 
+/**
+ * Animates the {@code target} in a circular motion centered at (<var>cx</var>, <var>cy</var>).
+ */
 public class CircleAnimation extends Animation<Shape> {
 
-	private Shape object;
+	private final Shape target;
 
-	private double centerx, centery, radius, startangle;
+	private final double centerX, centerY, rotateTo;
 
-	public CircleAnimation( Shape target, double cx, double cy, int runtime, DoubleUnaryOperator easing ) {
+	private double rotationRadius, startAngle;
+
+	private final boolean rotateRight;
+
+	public CircleAnimation( Shape target, double cx, double cy ) {
+		this(target, cx, cy, 360, true, DEFAULT_ANIM_RUNTIME, DEFAULT_EASING);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, double rotateTo ) {
+		this(target, cx, cy, rotateTo, true, DEFAULT_ANIM_RUNTIME, DEFAULT_EASING);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, boolean rotateRight ) {
+		this(target, cx, cy, 360, rotateRight, DEFAULT_ANIM_RUNTIME, DEFAULT_EASING);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, double rotateTo, boolean rotateRight ) {
+		this(target, cx, cy, rotateTo, rotateRight, DEFAULT_ANIM_RUNTIME, DEFAULT_EASING);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, int runtime ) {
+		this(target, cx, cy, 360, true, runtime, DEFAULT_EASING);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, boolean rotateRight, int runtime ) {
+		this(target, cx, cy, 360, rotateRight, runtime, DEFAULT_EASING);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, DoubleUnaryOperator easing ) {
+		this(target, cx, cy, 360, true, DEFAULT_ANIM_RUNTIME, easing);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, boolean rotateRight, DoubleUnaryOperator easing ) {
+		this(target, cx, cy, 360, rotateRight, DEFAULT_ANIM_RUNTIME, easing);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, double rotateTo, int runtime, DoubleUnaryOperator easing ) {
+		this(target, cx, cy, rotateTo, true, runtime, easing);
+	}
+
+	public CircleAnimation( Shape target, double cx, double cy, double rotateTo, boolean rotateRight, int runtime, DoubleUnaryOperator easing ) {
 		super(runtime, easing);
-		object = target;
-		centerx = cx;
-		centery = cy;
-		Vector vec = new Vector(target.getX(), target.getY()).sub(cx, cy);
-		startangle = vec.heading();
-		radius = vec.length();
+		this.target = target;
+		this.centerX = cx;
+		this.centerY = cy;
+		this.rotateTo = Constants.radians(Constants.limit(rotateTo, 0, 360));
+		this.rotateRight = rotateRight;
+	}
+
+	@Override
+	public void initialize() {
+		Vector vec = new Vector(target.getX(), target.getY()).sub(centerX, centerY);
+		startAngle = vec.heading();
+		rotationRadius = vec.length();
 	}
 
 	@Override
 	public Shape getAnimationTarget() {
-		return object;
+		return target;
 	}
 
 	@Override
 	public void animate( double e ) {
-		double angle = startangle + Constants.radians(Constants.interpolate(0, 360, e));
-		double x = centerx + radius * Constants.cos(angle);
-		double y = centery + radius * Constants.sin(angle);
-		object.moveTo(x, y);
+		double angle = startAngle;
+		if( rotateRight ) {
+			angle += Constants.interpolate(0, rotateTo, e);
+		} else {
+			angle -= Constants.interpolate(0, rotateTo, e);
+		}
+		double x = centerX + rotationRadius * Constants.cos(angle);
+		double y = centerY + rotationRadius * Constants.sin(angle);
+		target.moveTo(x, y);
 	}
 
 }

src/main/java/schule/ngb/zm/anim/ContinousAnimation.java

@@ -8,9 +8,9 @@ public class ContinousAnimation<T> extends Animation<T> {
 	private int lag = 0;
 
 	/**
-	 * Speichert eine Approximation der aktuellen Steigung der Easing-Funktion,
-	 * um im Fall {@code easeInOnly == true} nach dem ersten Durchlauf die
-	 * passende Geschwindigkeit beizubehalten.
+	 * Speichert eine Approximation der aktuellen Steigung der Easing-Funktion, um im Fall
+	 * {@code easeInOnly == true} nach dem ersten Durchlauf die passende Geschwindigkeit
+	 * beizubehalten.
 	 */
 	private double m = 1.0, lastEase = 0.0;
 
@@ -29,7 +29,7 @@ public class ContinousAnimation<T> extends Animation<T> {
 	}
 
 	private ContinousAnimation( Animation<T> baseAnimation, int lag, boolean easeInOnly ) {
-		super(baseAnimation.getRuntime(), baseAnimation.getEasing());
+		super(baseAnimation.getRuntime() + lag, baseAnimation.getEasing());
 		this.baseAnimation = baseAnimation;
 		this.lag = lag;
 		this.easeInOnly = easeInOnly;
@@ -40,35 +40,80 @@ public class ContinousAnimation<T> extends Animation<T> {
 		return baseAnimation.getAnimationTarget();
 	}
 
+	@Override
+	public int getRuntime() {
+		return Integer.MAX_VALUE;
+	}
+
+	//	@Override
+//	public void update( double delta ) {
+//		elapsedTime += (int) (delta * 1000);
+//		if( elapsedTime >= runtime + lag ) {
+//			elapsedTime %= (runtime + lag);
+//
+//			if( easeInOnly && easing != null ) {
+//				easing = null;
+//				// runtime = (int)((1.0/m)*(runtime + lag));
+//			}
+//		}
+//
+//		double t = (double) elapsedTime / (double) runtime;
+//		if( t >= 1.0 ) {
+//			t = 1.0;
+//		}
+//		if( easing != null ) {
+//			double e = easing.applyAsDouble(t);
+//			animate(e);
+//			m = (e-lastEase)/(delta*1000/(asDouble(runtime)));
+//			lastEase = e;
+//		} else {
+//			animate(t);
+//		}
+//	}
+
+
+	@Override
+	public void finish() {
+		baseAnimation.elapsedTime = baseAnimation.getRuntime();
+		baseAnimation.stop();
+	}
+
+	@Override
+	public void initialize() {
+		baseAnimation.start();
+	}
+
+	@Override
+	public void setRuntime( int pRuntime ) {
+		baseAnimation.setRuntime(pRuntime);
+		runtime = pRuntime + lag;
+	}
+
 	@Override
 	public void update( double delta ) {
-		elapsedTime += (int) (delta * 1000);
-		if( elapsedTime >= runtime + lag ) {
-			elapsedTime %= (runtime + lag);
+		int currentRuntime = elapsedTime + (int) (delta * 1000);
+		if( currentRuntime >= runtime + lag ) {
+			elapsedTime = currentRuntime % (runtime + lag);
 
 			if( easeInOnly && easing != null ) {
-				easing = null;
+				easing = Easing.linear();
 				// runtime = (int)((1.0/m)*(runtime + lag));
 			}
 		}
 
-		double t = (double) elapsedTime / (double) runtime;
-		if( t >= 1.0 ) {
-			t = 1.0;
-		}
-		if( easing != null ) {
-			double e = easing.applyAsDouble(t);
-			animate(e);
-			m = (e-lastEase)/(delta*1000/(asDouble(runtime)));
-			lastEase = e;
-		} else {
-			animate(t);
-		}
+		super.update(delta);
 	}
 
 	@Override
 	public void animate( double e ) {
+//		double t = (double) elapsedTime / (double) runtime;
+//		if( t >= 1.0 ) {
+//			t = 1.0;
+//		}
+		baseAnimation.elapsedTime = elapsedTime;
 		baseAnimation.animate(e);
+		m = (e - lastEase) / (delta * 1000 / (asDouble(runtime)));
+		lastEase = e;
 	}
 
 }

src/main/java/schule/ngb/zm/anim/FadeAnimation.java

@@ -13,32 +13,51 @@ public class FadeAnimation extends Animation<Shape> {
 
 	public static final int FADE_OUT = 0;
 
-	private Shape object;
+	private final Shape target;
+
+	private final int targetAlpha;
 
 	private Color fill, stroke;
 
-	private int fillAlpha, strokeAlpha, tAlpha;
+	private int fillAlpha, strokeAlpha;
 
-	public FadeAnimation( Shape object, int alpha, int runtime, DoubleUnaryOperator easing ) {
+	public FadeAnimation( Shape target, int targetAlpha ) {
+		this(target, targetAlpha, DEFAULT_ANIM_RUNTIME, DEFAULT_EASING);
+	}
+
+	public FadeAnimation( Shape target, int targetAlpha, int runtime ) {
+		this(target, targetAlpha, runtime, DEFAULT_EASING);
+	}
+
+	public FadeAnimation( Shape target, int runtime, DoubleUnaryOperator easing ) {
+		this(target, 0, runtime, easing);
+	}
+
+	public FadeAnimation( Shape target, int targetAlpha, int runtime, DoubleUnaryOperator easing ) {
 		super(runtime, easing);
 
-		this.object = object;
-		fill = object.getFillColor();
+		this.target = target;
+		this.targetAlpha = targetAlpha;
+	}
+
+	@Override
+	public void initialize() {
+		fill = target.getFillColor();
 		fillAlpha = fill.getAlpha();
-		stroke = object.getStrokeColor();
+		stroke = target.getStrokeColor();
 		strokeAlpha = stroke.getAlpha();
-		tAlpha = alpha;
+
 	}
 
 	@Override
 	public Shape getAnimationTarget() {
-		return object;
+		return target;
 	}
 
 	@Override
 	public void animate( double e ) {
-		object.setFillColor(new Color(fill, (int) Constants.interpolate(fillAlpha, tAlpha, e)));
-		object.setStrokeColor(new Color(stroke, (int) Constants.interpolate(strokeAlpha, tAlpha, e)));
+		target.setFillColor(fill, (int) Constants.interpolate(fillAlpha, targetAlpha, e));
+		target.setStrokeColor(stroke, (int) Constants.interpolate(strokeAlpha, targetAlpha, e));
 	}
 
 }

src/main/java/schule/ngb/zm/anim/FillAnimation.java

@@ -1,23 +1,28 @@
 package schule.ngb.zm.anim;
 
 import schule.ngb.zm.Color;
-import schule.ngb.zm.Constants;
 import schule.ngb.zm.shapes.Shape;
 
 import java.util.function.DoubleUnaryOperator;
 
 public class FillAnimation extends Animation<Shape> {
 
-	private Shape object;
+	private final Shape object;
 
-	private Color oFill, tFill;
+	private Color originFill;
 
-	public FillAnimation( Shape object, Color newFill, int runtime, DoubleUnaryOperator easing ) {
+	private final Color targetFill;
+
+	public FillAnimation( Shape target, Color newFill, int runtime, DoubleUnaryOperator easing ) {
 		super(runtime, easing);
 
-		this.object = object;
-		oFill = object.getFillColor();
-		tFill = newFill;
+		this.object = target;
+		targetFill = newFill;
+	}
+
+	@Override
+	public void initialize() {
+		originFill = object.getFillColor();
 	}
 
 	@Override
@@ -27,7 +32,7 @@ public class FillAnimation extends Animation<Shape> {
 
 	@Override
 	public void animate( double e ) {
-		object.setFillColor(Color.interpolate(oFill, tFill, e));
+		object.setFillColor(Color.interpolate(originFill, targetFill, e));
 	}
 
 }

src/main/java/schule/ngb/zm/anim/MoveAnimation.java

@@ -1,28 +1,31 @@
 package schule.ngb.zm.anim;
 
-import schule.ngb.zm.Color;
 import schule.ngb.zm.Constants;
-import schule.ngb.zm.shapes.Circle;
-import schule.ngb.zm.shapes.Ellipse;
-import schule.ngb.zm.shapes.Rectangle;
 import schule.ngb.zm.shapes.Shape;
 
 import java.util.function.DoubleUnaryOperator;
 
 public class MoveAnimation extends Animation<Shape> {
 
-	private Shape object;
+	private final Shape object;
 
-	private double oX, oY, tX, tY;
+	private final double targetX, targetY;
 
-	public MoveAnimation( Shape object, double x, double y, int runtime, DoubleUnaryOperator easing ) {
+	private double originX, originY;
+
+
+	public MoveAnimation( Shape target, double targetX, double targetY, int runtime, DoubleUnaryOperator easing ) {
 		super(runtime, easing);
 
-		this.object = object;
-		oX = object.getX();
-		oY = object.getY();
-		tX = x;
-		tY = y;
+		this.object = target;
+		this.targetX = targetX;
+		this.targetY = targetY;
+	}
+
+	@Override
+	public void initialize() {
+		originX = object.getX();
+		originY = object.getY();
 	}
 
 	@Override
@@ -32,8 +35,8 @@ public class MoveAnimation extends Animation<Shape> {
 
 	@Override
 	public void animate( double e ) {
-		object.setX(Constants.interpolate(oX, tX, e));
-		object.setY(Constants.interpolate(oY, tY, e));
+		object.setX(Constants.interpolate(originX, targetX, e));
+		object.setY(Constants.interpolate(originY, targetY, e));
 	}
 
 }

src/main/java/schule/ngb/zm/layers/DrawingLayer.java

@@ -404,6 +404,11 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 		return shapeDelegate.getStrokeType();
 	}
 
+	@Override
+	public Options.StrokeJoin getStrokeJoin() {
+		return shapeDelegate.getStrokeJoin();
+	}
+
 	/**
 	 * Setzt den Typ der Kontur. Erlaubte Werte sind {@link #DASHED},
 	 * {@link #DOTTED} und {@link #SOLID}.
@@ -923,12 +928,43 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 		}
 	}
 
+	public void curveTo( double ctrlX, double ctrlY, double x, double y ) {
+		if( !pathStarted ) {
+			path.moveTo(x, y);
+			pathStarted = true;
+		} else {
+			path.quadTo(
+				ctrlX, ctrlY,
+				x, y
+			);
+		}
+	}
+
+	public void curveTo( double ctrlX1, double ctrlY1, double ctrlX2, double ctrlY2, double x, double y ) {
+		if( !pathStarted ) {
+			path.moveTo(x, y);
+			pathStarted = true;
+		} else {
+			path.curveTo(
+				ctrlX1, ctrlY1,
+				ctrlX2, ctrlY2,
+				x, y
+			);
+		}
+	}
+
 	/**
 	 * Beendet eine zuvor {@link #beginShape() begonnene} Freihand-Form und
 	 * zeichent sie auf die Zeichenebene.
 	 */
 	public void endShape() {
-		path.closePath();
+		endShape(CLOSED);
+	}
+
+	public void endShape( Options.PathType closingType ) {
+		if( closingType == Options.PathType.CLOSED ) {
+			path.closePath();
+		}
 		path.trimToSize();
 		pathStarted = false;
 
@@ -949,7 +985,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @see ImageLoader#loadImage(String)
 	 */
 	public void image( String imageSource, double x, double y ) {
-		image(ImageLoader.loadImage(imageSource), x, y, 1.0, shapeDelegate.getAnchor());
+		imageScale(ImageLoader.loadImage(imageSource), x, y, 1.0, shapeDelegate.getAnchor());
 	}
 
 	/**
@@ -966,7 +1002,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @see ImageLoader#loadImage(String)
 	 */
 	public void image( String imageSource, double x, double y, Options.Direction anchor ) {
-		image(ImageLoader.loadImage(imageSource), x, y, 1.0, anchor);
+		imageScale(ImageLoader.loadImage(imageSource), x, y, 1.0, anchor);
 	}
 
 	/**
@@ -974,8 +1010,9 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * Koordinaten auf die Zeichenebene. Das Bild wird um den angegebenen Faktor
 	 * skaliert.
 	 * <p>
-	 * Siehe {@link #image(Image, double, double, double, Options.Direction)}
-	 * für mehr Details.
+	 * Siehe
+	 * {@link #imageScale(Image, double, double, double, Options.Direction)} für
+	 * mehr Details.
 	 *
 	 * @param imageSource Die Bildquelle.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -983,8 +1020,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param scale Der Skalierungsfaktor des Bildes.
 	 * @see ImageLoader#loadImage(String)
 	 */
-	public void image( String imageSource, double x, double y, double scale ) {
-		image(ImageLoader.loadImage(imageSource), x, y, scale, shapeDelegate.getAnchor());
+	public void imageScale( String imageSource, double x, double y, double scale ) {
+		imageScale(ImageLoader.loadImage(imageSource), x, y, scale, shapeDelegate.getAnchor());
 	}
 
 	/**
@@ -992,8 +1029,9 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * Koordinaten auf die Zeichenebene. Das Bild wird um den angegebenen Faktor
 	 * skaliert und der angegebene Ankerpunkt verwendet.
 	 * <p>
-	 * Siehe {@link #image(Image, double, double, double, Options.Direction)}
-	 * für mehr Details.
+	 * Siehe
+	 * {@link #imageScale(Image, double, double, double, Options.Direction)} für
+	 * mehr Details.
 	 *
 	 * @param imageSource Die Bildquelle.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -1002,8 +1040,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param anchor Der Ankerpunkt.
 	 * @see ImageLoader#loadImage(String)
 	 */
-	public void image( String imageSource, double x, double y, double scale, Options.Direction anchor ) {
-		image(ImageLoader.loadImage(imageSource), x, y, scale, anchor);
+	public void imageScale( String imageSource, double x, double y, double scale, Options.Direction anchor ) {
+		imageScale(ImageLoader.loadImage(imageSource), x, y, scale, anchor);
 	}
 
 	/**
@@ -1015,23 +1053,24 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param y y-Koordinate des Ankerpunktes.
 	 */
 	public void image( Image image, double x, double y ) {
-		image(image, x, y, 1.0, shapeDelegate.getAnchor());
+		imageScale(image, x, y, 1.0, shapeDelegate.getAnchor());
 	}
 
 	/**
 	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten auf die
 	 * Zeichenebene. Das Bild wird um den angegebenen Faktor skaliert.
 	 * <p>
-	 * Siehe {@link #image(Image, double, double, double, Options.Direction)}
-	 * für mehr Details.
+	 * Siehe
+	 * {@link #imageScale(Image, double, double, double, Options.Direction)} für
+	 * mehr Details.
 	 *
 	 * @param image Das vorher geladene Bild.
 	 * @param x x-Koordinate des Ankerpunktes.
 	 * @param y y-Koordinate des Ankerpunktes.
 	 * @param scale Der Skalierungsfaktor des Bildes.
 	 */
-	public void image( Image image, double x, double y, double scale ) {
-		image(image, x, y, scale, shapeDelegate.getAnchor());
+	public void imageScale( Image image, double x, double y, double scale ) {
+		imageScale(image, x, y, scale, shapeDelegate.getAnchor());
 	}
 
 	/**
@@ -1046,8 +1085,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * Das Seitenverhältnis wird immer beibehalten.
 	 * <p>
 	 * Soll das Bild innerhalb eines vorgegebenen Rechtecks liegen, sollte
-	 * {@link #image(Image, double, double, double, double, Options.Direction)}
-	 * verwendet werden.
+	 * {@link #imageScale(Image, double, double, double, double,
+	 * Options.Direction)} verwendet werden.
 	 *
 	 * @param image Das vorher geladene Bild.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -1055,7 +1094,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param scale Der Skalierungsfaktor des Bildes.
 	 * @param anchor Der Ankerpunkt.
 	 */
-	public void image( Image image, double x, double y, double scale, Options.Direction anchor ) {
+	public void imageScale( Image image, double x, double y, double scale, Options.Direction anchor ) {
 		/*if( image != null ) {
 			double neww = image.getWidth(null) * scale;
 			double newh = image.getHeight(null) * scale;
@@ -1064,7 +1103,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 		}*/
 		double neww = image.getWidth(null) * scale;
 		double newh = image.getHeight(null) * scale;
-		image(image, x, y, neww, newh, anchor);
+		imageScale(image, x, y, neww, newh, anchor);
 	}
 
 	/**
@@ -1072,8 +1111,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * Koordinaten in der angegebenen Größe auf die Zeichenebene.
 	 * <p>
 	 * Siehe
-	 * {@link #image(Image, double, double, double, double, Options.Direction)}
-	 * für mehr Details.
+	 * {@link #imageScale(Image, double, double, double, double,
+	 * Options.Direction)} für mehr Details.
 	 *
 	 * @param imageSource Die Bildquelle.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -1082,8 +1121,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
 	 * @see ImageLoader#loadImage(String)
 	 */
-	public void image( String imageSource, double x, double y, double width, double height ) {
-		image(ImageLoader.loadImage(imageSource), x, y, width, height, shapeDelegate.getAnchor());
+	public void imageScale( String imageSource, double x, double y, double width, double height ) {
+		imageScale(ImageLoader.loadImage(imageSource), x, y, width, height, shapeDelegate.getAnchor());
 	}
 
 	/**
@@ -1092,8 +1131,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * angegebene Ankerpunkt verwendet.
 	 * <p>
 	 * Siehe
-	 * {@link #image(Image, double, double, double, double, Options.Direction)}
-	 * für mehr Details.
+	 * {@link #imageScale(Image, double, double, double, double,
+	 * Options.Direction)} für mehr Details.
 	 *
 	 * @param imageSource Die Bildquelle.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -1103,8 +1142,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param anchor Der Ankerpunkt.
 	 * @see ImageLoader#loadImage(String)
 	 */
-	public void image( String imageSource, double x, double y, double width, double height, Options.Direction anchor ) {
-		image(ImageLoader.loadImage(imageSource), x, y, width, height, anchor);
+	public void imageScale( String imageSource, double x, double y, double width, double height, Options.Direction anchor ) {
+		imageScale(ImageLoader.loadImage(imageSource), x, y, width, height, anchor);
 	}
 
 	/**
@@ -1112,8 +1151,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * angegebenen Größe auf die Zeichenebene.
 	 * <p>
 	 * Siehe
-	 * {@link #image(Image, double, double, double, double, Options.Direction)}
-	 * für mehr Details.
+	 * {@link #imageScale(Image, double, double, double, double,
+	 * Options.Direction)} für mehr Details.
 	 *
 	 * @param image Ein Bild-Objekt.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -1121,8 +1160,8 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
 	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
 	 */
-	public void image( Image image, double x, double y, double width, double height ) {
-		image(image, x, y, width, height, shapeDelegate.getAnchor());
+	public void imageScale( Image image, double x, double y, double width, double height ) {
+		imageScale(image, x, y, width, height, shapeDelegate.getAnchor());
 	}
 
 	/**
@@ -1140,7 +1179,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * <p>
 	 * Soll die Bildgröße unter Beachtung der Abmessungen um einen Faktor
 	 * verändert werden, sollte
-	 * {@link #image(Image, double, double, double, Options.Direction)}
+	 * {@link #imageScale(Image, double, double, double, Options.Direction)}
 	 * verwendet werden.
 	 *
 	 * @param image Ein Bild-Objekt.
@@ -1150,17 +1189,163 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
 	 * @param anchor Der Ankerpunkt.
 	 */
-	public void image( Image image, double x, double y, double width, double height, Options.Direction anchor ) {
+	public void imageScale( Image image, double x, double y, double width, double height, Options.Direction anchor ) {
+		imageRotateAndScale(image, x, y, 0, width, height, anchor);
+	}
+
+	/**
+	 * Zeichnet das Bild von der angegebenen Bildquelle an den angegebenen
+	 * Koordinaten mit der angegebenen Drehung auf die Zeichenebene.
+	 * <p>
+	 * Das Bild wird um seinen Mittelpunkt als Rotationszentrum gedreht.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 */
+	public void imageRotate( String imageSource, double x, double y, double angle ) {
+		imageRotate(ImageLoader.loadImage(imageSource), x, y, angle, shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet das Bild von der angegebenen Bildquelle an den angegebenen
+	 * Koordinaten mit der angegebenen Drehung auf die Zeichenebene. Der
+	 * angegebene Ankerpunkt wird verwendet.
+	 * <p>
+	 * Das Bild wird um seinen Mittelpunkt als Rotationszentrum gedreht.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 * @param anchor Der Ankerpunkt.
+	 */
+	public void imageRotate( String imageSource, double x, double y, double angle, Options.Direction anchor ) {
+		imageRotate(ImageLoader.loadImage(imageSource), x, y, angle, anchor);
+	}
+
+	/**
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten mit der
+	 * angegebenen Drehung auf die Zeichenebene.
+	 * <p>
+	 * Das Bild wird um seinen Mittelpunkt als Rotationszentrum gedreht.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 */
+	public void imageRotate( Image image, double x, double y, double angle ) {
+		imageRotateAndScale(image, x, y, angle, image.getWidth(null), image.getHeight(null), shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten mit der
+	 * angegebenen Drehung auf die Zeichenebene. Der angegebene Ankerpunkt wird
+	 * verwendet.
+	 * <p>
+	 * Das Bild wird um seinen Mittelpunkt als Rotationszentrum gedreht.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 * @param anchor Der Ankerpunkt.
+	 */
+	public void imageRotate( Image image, double x, double y, double angle, Options.Direction anchor ) {
+		imageRotateAndScale(image, x, y, angle, image.getWidth(null), image.getHeight(null), anchor);
+	}
+
+	/**
+	 * Zeichnet das Bild von der angegebenen Bildquelle an den angegebenen
+	 * Koordinaten mit der angegebenen Drehung in der angegebenen Größe auf die
+	 * Zeichenebene.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @see #imageRotate(String, double, double, double)
+	 * @see #imageScale(Image, double, double, double)
+	 */
+	public void imageRotateAndScale( String imageSource, double x, double y, double angle, double width, double height ) {
+		imageRotateAndScale(ImageLoader.loadImage(imageSource), x, y, angle, width, height, shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet das Bild von der angegebenen Bildquelle an den angegebenen
+	 * Koordinaten mit der angegebenen Drehung in der angegebenen Größe auf die
+	 * Zeichenebene. Der angegebene Ankerpunkt wird verwendet.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @param anchor Der Ankerpunkt.
+	 * @see #imageRotate(String, double, double, double)
+	 * @see #imageScale(Image, double, double, double)
+	 */
+	public void imageRotateAndScale( String imageSource, double x, double y, double angle, double width, double height, Options.Direction anchor ) {
+		imageRotateAndScale(ImageLoader.loadImage(imageSource), x, y, angle, width, height, anchor);
+	}
+
+	/**
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten mit der
+	 * angegebenen Drehung in der angegebenen Größe auf die Zeichenebene. Der
+	 * angegebene Ankerpunkt wird verwendet.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @see #imageRotate(String, double, double, double)
+	 * @see #imageScale(Image, double, double, double)
+	 */
+	public void imageRotateAndScale( Image image, double x, double y, double angle, double width, double height ) {
+		imageRotateAndScale(image, x, y, angle, width, height, shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten mit der
+	 * angegebenen Drehung in der angegebenen Größe auf die Zeichenebene. Der
+	 * angegebene Ankerpunkt wird verwendet.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param angle Winkel in Grad.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @param anchor Der Ankerpunkt.
+	 * @see #imageRotate(String, double, double, double)
+	 * @see #imageScale(Image, double, double, double)
+	 */
+	public void imageRotateAndScale( Image image, double x, double y, double angle, double width, double height, Options.Direction anchor ) {
 		// TODO: Use Validator or at least LOG a message if image == null?
 		if( image != null ) {
+			AffineTransform orig = drawing.getTransform();
+
+			int imgWidth = image.getWidth(null);
+			int imgHeight = image.getHeight(null);
+
 			if( width == 0 ) {
-				width = (height / image.getHeight(null)) * image.getWidth(null);
+				width = (height / imgHeight) * imgWidth;
 			} else if( height == 0 ) {
-				height = (width / image.getWidth(null)) * image.getHeight(null);
+				height = (width / imgWidth) * imgHeight;
 			}
 
 			Point2D.Double anchorPoint = getOriginPoint(x, y, width, height, anchor);
+			drawing.rotate(Math.toRadians(angle), anchorPoint.x + width / 2, anchorPoint.y + height / 2);
 			drawing.drawImage(image, (int) anchorPoint.x, (int) anchorPoint.y, (int) width, (int) height, null);
+
+			drawing.setTransform(orig);
 		}
 	}
 

src/main/java/schule/ngb/zm/layers/ShapesLayer.java

@@ -1,6 +1,7 @@
 package schule.ngb.zm.layers;
 
 import schule.ngb.zm.Layer;
+import schule.ngb.zm.Updatable;
 import schule.ngb.zm.anim.Animation;
 import schule.ngb.zm.anim.AnimationFacade;
 import schule.ngb.zm.anim.Easing;
@@ -24,20 +25,26 @@ public class ShapesLayer extends Layer {
 	 */
 	protected boolean clearBeforeDraw = true;
 
-	private final List<Shape> shapes;
+	protected boolean updateShapes = true;
+
+	protected final List<Shape> shapes;
 
 	private final List<Animation<? extends Shape>> animations;
 
+	private final List<Updatable> updatables;
+
 	public ShapesLayer() {
 		super();
 		shapes = new LinkedList<>();
 		animations = new LinkedList<>();
+		updatables = new LinkedList<>();
 	}
 
 	public ShapesLayer( int width, int height ) {
 		super(width, height);
 		shapes = new LinkedList<>();
 		animations = new LinkedList<>();
+		updatables = new LinkedList<>();
 	}
 
 	public Shape getShape( int index ) {
@@ -70,12 +77,24 @@ public class ShapesLayer extends Layer {
 	public void add( Shape... shapes ) {
 		synchronized( this.shapes ) {
 			Collections.addAll(this.shapes, shapes);
+
+			for( Shape s : shapes ) {
+				if( Updatable.class.isInstance(s) ) {
+					updatables.add((Updatable) s);
+				}
+			}
 		}
 	}
 
 	public void add( Collection<Shape> shapes ) {
 		synchronized( this.shapes ) {
 			this.shapes.addAll(shapes);
+
+			for( Shape s : shapes ) {
+				if( Updatable.class.isInstance(s) ) {
+					updatables.add((Updatable) s);
+				}
+			}
 		}
 	}
 
@@ -139,6 +158,27 @@ public class ShapesLayer extends Layer {
 
 	@Override
 	public void update( double delta ) {
+		if( updateShapes ) {
+			synchronized( shapes ) {
+				List<Updatable> uit = List.copyOf(updatables);
+				for( Updatable u : uit ) {
+					if( u.isActive() ) {
+						u.update(delta);
+					}
+				}
+			}
+
+			/*
+			Iterator<Updatable> uit = updatables.iterator();
+			while( uit.hasNext() ) {
+				Updatable u = uit.next();
+				if( u.isActive() ) {
+					u.update(delta);
+				}
+			}
+			*/
+		}
+
 		Iterator<Animation<? extends Shape>> it = animations.iterator();
 		while( it.hasNext() ) {
 			Animation<? extends Shape> anim = it.next();

src/main/java/schule/ngb/zm/layers/TurtleLayer.java

@@ -230,6 +230,11 @@ public class TurtleLayer extends Layer implements Strokeable, Fillable {
 		return mainTurtle.getStrokeType();
 	}
 
+	@Override
+	public Options.StrokeJoin getStrokeJoin() {
+		return mainTurtle.getStrokeJoin();
+	}
+
 	@Override
 	public void setStrokeType( Options.StrokeType type ) {
 		mainTurtle.setStrokeType(type);

src/main/java/schule/ngb/zm/media/Sound.java

@@ -235,8 +235,8 @@ public class Sound implements Audio {
 	}
 
 	/**
-	 * Lädt falls nötig den {@link Clip} für die
-	 * {@link #audioSource Audioquelle} und startet die Wiedergabe.
+	 * Lädt, falls nötig, den {@link Clip} für die
+	 * {@link #audioSource Audioquelle}.
 	 *
 	 * @return {@code true}, wenn der Clip geöffnet werden konnte, {@code false}
 	 * 	sonst.
@@ -264,10 +264,6 @@ public class Sound implements Audio {
 							}
 						} else if( event.getType() == LineEvent.Type.STOP ) {
 							playbackStopped();
-
-							if( eventDispatcher != null ) {
-								eventDispatcher.dispatchEvent("stop", Sound.this);
-							}
 						}
 					}
 				});
@@ -313,6 +309,10 @@ public class Sound implements Audio {
 	private void playbackStopped() {
 		playing = false;
 
+		if( eventDispatcher != null ) {
+			eventDispatcher.dispatchEvent("stop", Sound.this);
+		}
+
 		if( disposeAfterPlay ) {
 			this.dispose();
 			disposeAfterPlay = false;

src/main/java/schule/ngb/zm/particles/BasicParticle.java

@@ -0,0 +1,77 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.Color;
+import schule.ngb.zm.Vector;
+
+import java.awt.Graphics2D;
+
+public class BasicParticle extends Particle {
+
+	protected Color color, startColor, finalColor;
+
+
+	public BasicParticle() {
+		super();
+	}
+
+	public BasicParticle( Color startColor ) {
+		this(startColor, null);
+	}
+
+	public BasicParticle( Color startColor, Color finalColor ) {
+		super();
+
+		this.color = startColor;
+		this.startColor = startColor;
+		this.finalColor = finalColor;
+	}
+
+	public Color getColor() {
+		return color;
+	}
+
+	public void setColor( Color pColor ) {
+		this.color = pColor;
+	}
+
+	public Color getStartColor() {
+		return startColor;
+	}
+
+	public void setStartColor( Color pStartColor ) {
+		this.startColor = pStartColor;
+	}
+
+	public Color getFinalColor() {
+		return finalColor;
+	}
+
+	public void setFinalColor( Color pFinalColor ) {
+		this.finalColor = pFinalColor;
+	}
+
+	@Override
+	public void spawn( int pLifetime, Vector pPosition, Vector pVelocity ) {
+		super.spawn(pLifetime, pPosition, pVelocity);
+		this.color = this.startColor;
+	}
+
+	@Override
+	public void update( double delta ) {
+		super.update(delta);
+
+		if( isActive() && startColor != null && finalColor != null ) {
+			double t = 1.0 - lifetime / maxLifetime;
+			this.color = Color.interpolate(startColor, finalColor, t);
+		}
+	}
+
+	@Override
+	public void draw( Graphics2D graphics ) {
+		if( isActive() && this.color != null ) {
+			graphics.setColor(this.color.getJavaColor());
+			graphics.fillOval(position.getIntX() - 3, position.getIntY() - 3, 6, 6);
+		}
+	}
+
+}

src/main/java/schule/ngb/zm/particles/BasicParticleFactory.java

@@ -0,0 +1,43 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.Color;
+
+public class BasicParticleFactory implements ParticleFactory {
+
+	private final Color startColor;
+
+	private final Color finalColor;
+
+	private boolean fadeOut = true;
+
+	public BasicParticleFactory() {
+		this(null, null);
+	}
+
+	public BasicParticleFactory( Color startColor ) {
+		this(startColor, null);
+	}
+
+	public BasicParticleFactory( Color startColor, Color finalColor ) {
+		this.startColor = startColor;
+		this.finalColor = finalColor;
+	}
+
+	public void setFadeOut( boolean pFadeOut ) {
+		this.fadeOut = pFadeOut;
+	}
+
+	@Override
+	public Particle createParticle() {
+		Color finalClr = finalColor;
+		if( fadeOut ) {
+			if( finalColor != null ) {
+				finalClr = new Color(finalColor, 0);
+			} else if( startColor != null ) {
+				finalClr = new Color(startColor, 0);
+			}
+		}
+		return new BasicParticle(startColor, finalClr);
+	}
+
+}

src/main/java/schule/ngb/zm/particles/GenericParticleFactory.java

@@ -0,0 +1,49 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.util.Log;
+
+import java.util.Arrays;
+import java.util.function.Supplier;
+
+public class GenericParticleFactory<T extends Particle> implements ParticleFactory {
+
+	private final Class<T> type;
+
+	private final Supplier<T> supplier;
+
+	public GenericParticleFactory( Class<T> type, Object... params ) {
+		this.type = type;
+
+		// Create paramTypes array once
+		Class<?>[] paramTypes = new Class<?>[params.length];
+		for( int i = 0; i < params.length; i++ ) {
+			paramTypes[i] = params[i].getClass();
+		}
+
+		this.supplier = () -> {
+			T p = null;
+			try {
+				p = GenericParticleFactory.this.type.getDeclaredConstructor(paramTypes).newInstance(params);
+			} catch( Exception ex ) {
+				LOG.error( ex,
+					"Unable to create new Particle of type %s",
+					GenericParticleFactory.this.type.getCanonicalName()
+				);
+			}
+			return p;
+		};
+	}
+
+	public GenericParticleFactory( Supplier<T> supplier ) {
+		this.supplier = supplier;
+		this.type = (Class<T>)supplier.get().getClass();
+	}
+
+	@Override
+	public Particle createParticle() {
+		return this.supplier.get();
+	}
+
+	private static final Log LOG = Log.getLogger(GenericParticleFactory.class);
+
+}

src/main/java/schule/ngb/zm/particles/Particle.java

@@ -0,0 +1,60 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.Drawable;
+import schule.ngb.zm.Updatable;
+import schule.ngb.zm.Vector;
+
+
+public abstract class Particle extends PhysicsObject implements Updatable, Drawable {
+
+	protected double maxLifetime = 0, lifetime = 0;
+
+
+	public Particle() {
+		super();
+	}
+
+	public void spawn( int pLifetime, Vector pPosition, Vector pVelocity ) {
+		this.maxLifetime = pLifetime;
+		this.lifetime = pLifetime;
+		this.position = pPosition.copy();
+		this.velocity = pVelocity.copy();
+		this.acceleration = new Vector();
+	}
+
+	@Override
+	public boolean isActive() {
+		return lifetime > 0;
+	}
+
+	@Override
+	public boolean isVisible() {
+		return isActive();
+	}
+
+	public double getLifetime() {
+		return lifetime;
+	}
+
+	public void setLifetime( double pLifetime ) {
+		this.lifetime = pLifetime;
+	}
+
+	public double getMaxLifetime() {
+		return maxLifetime;
+	}
+
+	public void setMaxLifetime( double pMaxLifetime ) {
+		this.maxLifetime = pMaxLifetime;
+	}
+
+	@Override
+	public void update( double delta ) {
+		super.update(delta);
+		// lifetime -= delta;
+		lifetime -= 1;
+
+		// TODO: (ngb) calculate delta based on lifetime?
+	}
+
+}

src/main/java/schule/ngb/zm/particles/ParticleEmitter.java

@@ -0,0 +1,174 @@
+package schule.ngb.zm.particles;
+
+
+import schule.ngb.zm.Drawable;
+import schule.ngb.zm.Updatable;
+import schule.ngb.zm.Vector;
+
+import java.awt.Graphics2D;
+
+public class ParticleEmitter implements Updatable, Drawable {
+
+	protected ParticleFactory particleFactory;
+
+	private int particlesPerFrame;
+
+	private int particleLifetime = 180;
+
+	private Particle[] particles;
+
+	private boolean active = false;
+
+	private Particle nextParticle;
+
+	public Vector position;
+
+	public Vector direction = new Vector();
+
+	public double strength = 100.0;
+
+	public int angle = 0;
+
+	public double randomness = 0.0;
+
+	// private Vortex vortex = null;
+
+	public ParticleEmitter( double pX, double pY, int pParticleLifetime, int pParticlesPerFrame, ParticleFactory pFactory ) {
+		this.position = new Vector(pX, pY);
+		this.particlesPerFrame = pParticlesPerFrame;
+		this.particleLifetime = pParticleLifetime;
+		this.particleFactory = pFactory;
+
+		// Create particle pool
+		this.particles = new Particle[particlesPerFrame * pParticleLifetime];
+		this.direction = Vector.random(8, 16).normalize();
+
+		// vortex = new Vortex(position.copy().add(-10, -10), -.2, 8);
+	}
+
+	@Override
+	public boolean isActive() {
+		return active;
+	}
+
+	@Override
+	public boolean isVisible() {
+		return active;
+	}
+
+	public void start() {
+		this.direction.normalize();
+
+		// Partikel initialisieren
+		for( int i = 0; i < particles.length; i++ ) {
+			particles[i] = particleFactory.createParticle();
+		}
+
+		active = true;
+	}
+
+	public void stop() {
+		for( int i = 0; i < particles.length; i++ ) {
+			particles[i].setLifetime(0);
+			particles[i] = null;
+		}
+		active = false;
+	}
+
+	private Particle getNextParticle() {
+		// TODO: improve by caching next particle
+		for( Particle p : particles ) {
+			if( p != null && !p.isActive() ) {
+				return p;
+			}
+		}
+		return null;
+	}
+
+	public void emitParticle() {
+		int ppf = particlesPerFrame;
+		Particle nextParticle = getNextParticle();
+		while( ppf > 0 && nextParticle != null ) {
+			int lifetime = (int) random(particleLifetime);
+
+			double rotation = (angle / 2.0) - (int) (Math.random() * angle);
+			Vector velocity = direction.copy().scale(strength).rotate(rotation);
+			velocity.scale(random());
+
+			nextParticle.spawn(lifetime, this.position, velocity);
+			nextParticle = getNextParticle();
+			ppf -= 1;
+		}
+	}
+
+	@Override
+	public void update( double delta ) {
+		emitParticle();
+
+		boolean _active = false;
+		for( Particle particle : particles ) {
+			if( particle != null ) {
+				if( particle.isActive() ) {
+//					if( vortex != null ) {
+//						vortex.attract(particle);
+//					}
+					particle.update(delta);
+					_active = true;
+				}
+			}
+		}
+		this.active = _active;
+	}
+
+	private double random() {
+		return 1.0 - (Math.random() * randomness);
+	}
+
+	private double random( double pZahl ) {
+		return pZahl * random();
+	}
+
+	@Override
+	public void draw( Graphics2D graphics ) {
+		java.awt.Color current = graphics.getColor();
+		for( Particle particle : particles ) {
+			if( particle != null && particle.isVisible() ) {
+				particle.draw(graphics);
+			}
+		}
+
+//		if( vortex != null ) {
+//			graphics.setColor(java.awt.Color.BLACK);
+//			double vscale = (4 * vortex.scale);
+//			graphics.fillOval((int) (vortex.position.x - vscale * .5), (int) (vortex.position.y - vscale * .5), (int) vscale, (int) vscale);
+//		}
+		graphics.setColor(current);
+	}
+
+
+	class Vortex {
+
+		Vector position;
+
+		double speed = 1.0, scale = 1.0;
+
+		public Vortex( Vector pPosition, double pSpeed, double pScale ) {
+			this.position = pPosition.copy();
+			this.scale = pScale;
+			this.speed = pSpeed;
+		}
+
+		public void attract( Particle pPartikel ) {
+			Vector diff = Vector.sub(pPartikel.position, this.position);
+			double dx = -diff.y * this.speed;
+			double dy = diff.x * this.speed;
+			double f = 1.0 / (1.0 + (dx * dx + dy * dy) / scale);
+
+			pPartikel.position.x += (diff.x - pPartikel.velocity.x) * f;
+			pPartikel.position.y += (diff.y - pPartikel.velocity.y) * f;
+
+		}
+
+	}
+
+}

src/main/java/schule/ngb/zm/particles/ParticleFactory.java

@@ -0,0 +1,7 @@
+package schule.ngb.zm.particles;
+
+public interface ParticleFactory {
+
+	Particle createParticle();
+
+}

src/main/java/schule/ngb/zm/particles/PhysicsObject.java

@@ -0,0 +1,69 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.Updatable;
+import schule.ngb.zm.Vector;
+
+
+public abstract class PhysicsObject implements Updatable {
+
+	protected Vector position, velocity, acceleration;
+
+	protected double mass = 1.0;
+
+
+	public PhysicsObject() {
+		position = new Vector();
+		velocity = new Vector();
+		acceleration = new Vector();
+	}
+
+	public PhysicsObject( Vector pPosition ) {
+		position = pPosition.copy();
+		velocity = new Vector();
+		acceleration = new Vector();
+	}
+
+	public Vector getAcceleration() {
+		return acceleration;
+	}
+
+	public void setAcceleration( Vector pAcceleration ) {
+		this.acceleration = pAcceleration;
+	}
+
+	public double getMass() {
+		return mass;
+	}
+
+	public void setMass( double pMass ) {
+		this.mass = pMass;
+	}
+
+	public Vector getPosition() {
+		return position;
+	}
+
+	public void setPosition( Vector pPosition ) {
+		this.position = pPosition;
+	}
+
+	public Vector getVelocity() {
+		return velocity;
+	}
+
+	public void setVelocity( Vector pVelocity ) {
+		this.velocity = pVelocity;
+	}
+
+	public void accelerate( Vector pAcceleration ) {
+		acceleration.add(Vector.div(pAcceleration, mass));
+	}
+
+	@Override
+	public void update( double delta ) {
+		velocity.add(acceleration);
+		position.add(Vector.scale(velocity, delta));
+		acceleration.scale(0.0);
+	}
+
+}

src/main/java/schule/ngb/zm/particles/StarParticle.java

@@ -0,0 +1,35 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.Color;
+
+import java.awt.Graphics2D;
+
+public class StarParticle extends BasicParticle {
+
+	public StarParticle() {
+		super();
+		this.startColor = Color.PURE_GREEN;
+	}
+
+	public StarParticle( Color startColor ) {
+		this(startColor, null);
+	}
+
+	public StarParticle( Color startColor, Color finalColor ) {
+		super();
+
+		this.color = startColor;
+		this.startColor = startColor;
+		this.finalColor = finalColor;
+	}
+
+	@Override
+	public void draw( Graphics2D graphics ) {
+		if( isActive() && this.color != null ) {
+			graphics.setColor(this.color.getJavaColor());
+			graphics.drawLine((int) position.x - 3, (int) position.y - 3, (int) position.x + 3, (int) position.y + 3);
+			graphics.drawLine((int) position.x + 3, (int) position.y - 3, (int) position.x - 3, (int) position.y + 3);
+		}
+	}
+
+}

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

@@ -1,5 +1,9 @@
 package schule.ngb.zm.shapes;
 
+import schule.ngb.zm.Options;
+
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
 import java.awt.geom.CubicCurve2D;
 import java.awt.geom.Point2D;
 import java.awt.geom.QuadCurve2D;
@@ -170,6 +174,30 @@ public class Curve extends Shape {
 		move(dx, dy);
 	}
 
+	@Override
+	public void draw( Graphics2D graphics, AffineTransform transform ) {
+		if( !visible ) {
+			return;
+		}
+
+		AffineTransform orig = graphics.getTransform();
+		if( transform != null ) {
+			//graphics.transform(transform);
+		}
+
+		graphics.translate(x, y);
+		graphics.rotate(Math.toRadians(rotation));
+
+		java.awt.Shape shape = getShape();
+
+		java.awt.Color currentColor = graphics.getColor();
+		fillShape(shape, graphics);
+		strokeShape(shape, graphics);
+		graphics.setColor(currentColor);
+
+		graphics.setTransform(orig);
+	}
+
 	@Override
 	public boolean equals( Object o ) {
 		if( this == o ) return true;

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

@@ -11,6 +11,7 @@ public class CustomShape extends Shape {
 	public CustomShape( double x, double y ) {
 		super(x, y);
 		path = new Path2D.Double();
+		path.moveTo(x, y);
 	}
 
 	public CustomShape( CustomShape custom ) {
@@ -36,7 +37,7 @@ public class CustomShape extends Shape {
 	}
 
 	public void lineTo( double x, double y ) {
-		path.lineTo(x - x, y - y);
+		path.lineTo(x - this.x, y - this.y);
 		calculateBounds();
 	}
 

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

@@ -404,6 +404,7 @@ public abstract class Shape extends BasicDrawable {
 			setStrokeColor(shape.getStrokeColor());
 			setStrokeWeight(shape.getStrokeWeight());
 			setStrokeType(shape.getStrokeType());
+			setStrokeJoin(shape.getStrokeJoin());
 			visible = shape.isVisible();
 			rotation = shape.getRotation();
 			scale(shape.getScale());

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

@@ -0,0 +1,204 @@
+package schule.ngb.zm.util;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Ein Cache ist ein {@link Map} Implementation, die Inhaltsobjekte in einer
+ * {@link Reference} speichert und als Zwischenspeicher für Objekte dienen kann,
+ * deren Erstellung aufwendig ist.
+ * <p>
+ * Für einen Cache ist nicht garantiert, dass ein eingefügtes Objekt beim
+ * nächsten Aufruf noch vorhanden ist, da die Referenz inzwischen vom Garbage
+ * Collector gelöscht worden sein kann.
+ * <p>
+ * Als interne Map wird einen {@link ConcurrentHashMap} verwendet.
+ * <p>
+ * Ein passender Cache wird mittels der Fabrikmethoden {@link #newSoftCache()}
+ * und {@link #newWeakCache()} erstellt.
+ * <pre><code>
+ * Cache&lt;String, Image&gt; imageCache = Cache.newSoftCache();
+ * </code></pre>
+ *
+ * @param <K> Der Typ der Schlüssel.
+ * @param <V> Der Typ der Objekte.
+ */
+public final class Cache<K, V> implements Map<K, V> {
+
+	/**
+	 * Erstellt einen Cache mit {@link SoftReference} Referenzen.
+	 *
+	 * @param <K> Der Typ der Schlüssel.
+	 * @param <V> Der Typ der Objekte.
+	 * @return Ein Cache.
+	 */
+	public static <K, V> Cache<K, V> newSoftCache() {
+		return new Cache<>(SoftReference::new);
+	}
+
+	/**
+	 * Erstellt einen Cache mit {@link WeakReference} Referenzen.
+	 *
+	 * @param <K> Der Typ der Schlüssel.
+	 * @param <V> Der Typ der Objekte.
+	 * @return Ein Cache.
+	 */
+	public static <K, V> Cache<K, V> newWeakCache() {
+		return new Cache<>(WeakReference::new);
+	}
+
+
+	private final Map<K, Reference<V>> cache = new ConcurrentHashMap<>();
+
+	private final Reference<V> NOCACHE;
+
+	private final Function<V, Reference<V>> refSupplier;
+
+	private Cache( Function<V, Reference<V>> refSupplier ) {
+		this.refSupplier = refSupplier;
+		NOCACHE = refSupplier.apply(null);
+	}
+
+	@Override
+	public int size() {
+		return cache.size();
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return cache.isEmpty();
+	}
+
+	@Override
+	public boolean containsKey( Object key ) {
+		return cache.containsKey(key) && cache.get(key).get() != null;
+	}
+
+	@Override
+	public boolean containsValue( Object value ) {
+		return cache.values().stream()
+			.anyMatch(( ref ) -> ref.get() != null && ref.get() == value);
+	}
+
+	@Override
+	public V get( Object key ) {
+		if( cache.containsKey(key) ) {
+			return cache.get(key).get();
+		}
+		return null;
+	}
+
+	/**
+	 * Deaktiviert das Caching für den angegebenen Schlüssel.
+	 * <p>
+	 * Folgende Aufrufe von {@link #put(Object, Object)} mit demselben Schlüssel
+	 * haben keinen Effekt. Um das Caching wieder zu aktivieren, muss
+	 * {@link #remove(Object)} mit dem Schlüssel aufgerufen werden,
+	 *
+	 * @param key Der Schlüssel.
+	 */
+	public void disableCache( K key ) {
+		cache.put(key, NOCACHE);
+	}
+
+	/**
+	 * Prüft, ob der für den angegebenen Schlüssel zuvor
+	 * {@link #disableCache(Object)} aufgerufen wurde.
+	 *
+	 * @param key Der Schlüssel.
+	 * @return {@code true}, wenn der Schlüssel nicht gespeichert wird.
+	 */
+	public boolean isCachingDisabled( K key ) {
+		return cache.get(key) == NOCACHE;
+	}
+
+	@Override
+	public V put( K key, V value ) {
+		if( !isCachingDisabled(key) ) {
+			V prev = remove(key);
+			cache.put(key, refSupplier.apply(value));
+			return prev;
+		} else {
+			return null;
+		}
+	}
+
+	@Override
+	public V remove( Object key ) {
+		Reference<V> ref = cache.get(key);
+		cache.remove(key);
+
+		V prev = null;
+		if( ref != null ) {
+			prev = ref.get();
+			ref.clear();
+		}
+		return prev;
+	}
+
+	@Override
+	public void putAll( Map<? extends K, ? extends V> m ) {
+		for( Entry<? extends K, ? extends V> e : m.entrySet() ) {
+			put(e.getKey(), e.getValue());
+		}
+	}
+
+	@Override
+	public void clear() {
+		cache.clear();
+	}
+
+	@Override
+	public Set<K> keySet() {
+		return cache.keySet();
+	}
+
+	@Override
+	public Collection<V> values() {
+		return cache.values().stream()
+			.filter(( ref ) -> ref.get() != null)
+			.map(( ref ) -> ref.get())
+			.collect(Collectors.toList());
+	}
+
+	@Override
+	public Set<Entry<K, V>> entrySet() {
+		return cache.entrySet().stream()
+			.filter(( e ) -> e.getValue() != null && e.getValue().get() != null)
+			.map(( e ) -> new SoftCacheEntryView(e.getKey()))
+			.collect(Collectors.toSet());
+	}
+
+	private final class SoftCacheEntryView implements Map.Entry<K, V> {
+
+		private K key;
+
+		public SoftCacheEntryView( K key ) {
+			this.key = key;
+		}
+
+		@Override
+		public K getKey() {
+			return key;
+		}
+
+		@Override
+		public V getValue() {
+			return Cache.this.get(key);
+		}
+
+		@Override
+		public V setValue( V value ) {
+			return Cache.this.put(key, value);
+		}
+
+	}
+
+}

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

@@ -5,7 +5,7 @@ import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
- * Eine Helferklasse, um Dinge zu zählen.
+ * Eine Hilfsklasse, um Dinge zu zählen.
  * <p>
  * Im einfachsten Fall kann der Zähler als geteilte Zählvariable genutzt werden,
  * die mit {@link #inc()} und {@link #dec()} aus verschiedenen Objekten oder

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

@@ -28,7 +28,7 @@ import static java.lang.Math.log;
 import static schule.ngb.zm.Constants.random;
 
 /**
- * Eine Helferklasse, um zufällige Beispieldaten zu erzeugen.
+ * Eine Hilfsklasse, um zufällige Beispieldaten zu erzeugen.
  * <p>
  * Die Klasse kann verschiedene Arten realistischer Beispieldaten erzeugen.
  * Unter anderem Namen, E-Mail-Adressen, Passwörter oder Platzhalter-Bilder.

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

@@ -3,7 +3,7 @@ package schule.ngb.zm.util;
 import java.util.concurrent.TimeUnit;
 
 /**
- * Helferklasse zur Zeitmessung im Nanosekundenbereich.
+ * Hilfsklasse zur Zeitmessung im Nanosekundenbereich.
  * <p>
  * Mit einem {@code Timer} kann zum Beispiel die Laufzeit eines Algorithmus
  * gemessen werden. Wie eine echte Stoppuhr läuft der {@code Timer} weiter, wenn

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

@@ -19,7 +19,7 @@ public class Validator {
 
 	public static final <T> T requireNotNull( T obj, Supplier<String> msg ) {
 		if( obj == null ) {
-			throw new NullPointerException(msg == null ? "Parameter may nut be null." : msg.get());
+			throw new NullPointerException(msg == null ? "Parameter may not be null." : msg.get());
 		}
 		return obj;
 	}

src/main/java/schule/ngb/zm/util/events/package-info.java

@@ -1,5 +1,5 @@
 /**
- * Dieses Paket enthält Helferklassen, die das Listener-Entwurfsmuster
+ * Dieses Paket enthält Hilfsklassen, die das Listener-Entwurfsmuster
  * umsetzen.
  */
 package schule.ngb.zm.util.events;

src/main/java/schule/ngb/zm/util/io/FileLoader.java

@@ -1,9 +1,11 @@
 package schule.ngb.zm.util.io;
 
 import schule.ngb.zm.util.Log;
+import schule.ngb.zm.util.Validator;
 
 import java.io.BufferedReader;
 import java.io.IOException;
+import java.net.MalformedURLException;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
@@ -11,9 +13,10 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
+import java.util.logging.Level;
 
 /**
- * Helferklasse, um Textdateien in verschiedenen Formaten einzulesen.
+ * Hilfsklasse, um Textdateien in verschiedenen Formaten einzulesen.
  */
 @SuppressWarnings( "unused" )
 public final class FileLoader {
@@ -63,6 +66,9 @@ public final class FileLoader {
 	 * @return Eine Liste mit den Zeilen der Textdatei.
 	 */
 	public static List<String> loadLines( String source, Charset charset ) {
+		Validator.requireNotNull(source, "source");
+		Validator.requireNotNull(charset, "charset");
+
 		try( BufferedReader reader = ResourceStreamProvider.getReader(source, charset) ) {
 			List<String> result = new ArrayList<>();
 
@@ -72,8 +78,11 @@ public final class FileLoader {
 			}
 
 			return result;
+		} catch( MalformedURLException muex ) {
+			LOG.warn("Could not find resource for <%s>", source);
+			return Collections.emptyList();
 		} catch( IOException ex ) {
-			LOG.error(ex, "Error while loading lines from source <%s>", source);
+			LOG.warn(ex, "Error while loading lines from source <%s>", source);
 			return Collections.emptyList();
 		}
 	}
@@ -101,6 +110,9 @@ public final class FileLoader {
 	 * @return Der Inhalt der Textdatei.
 	 */
 	public static String loadText( String source, Charset charset ) {
+		Validator.requireNotNull(source, "source");
+		Validator.requireNotNull(charset, "charset");
+
 		try( BufferedReader reader = ResourceStreamProvider.getReader(source, charset) ) {
 			StringBuilder result = new StringBuilder();
 
@@ -110,8 +122,11 @@ public final class FileLoader {
 			}
 
 			return result.toString();
+		} catch( MalformedURLException muex ) {
+			LOG.warn("Could not find resource for <%s>", source);
+			return "";
 		} catch( IOException ex ) {
-			LOG.error(ex, "Error while loading string from source <%s>", source);
+			LOG.warn(ex, "Error while loading string from source <%s>", source);
 			return "";
 		}
 	}
@@ -166,34 +181,39 @@ public final class FileLoader {
 		).toArray(String[][]::new);
 	}
 
-	public static double[][] loadValues( String source, char separator, boolean skipFirst ) {
+	public static double[][] loadValues( String source, String separator, boolean skipFirst ) {
 		return loadValues(source, separator, skipFirst, UTF8);
 	}
 
 	/**
-	 * Lädt Double-Werte aus einer CSV Datei in ein zweidimensionales Array.
+	 * Lädt Double-Werte aus einer Text-Datei in ein zweidimensionales Array.
 	 * <p>
-	 * Die gelesenen Strings werden mit {@link Double#parseDouble(String)} in
-	 * {@code double} umgeformt. Es leigt in der Verantwortung des Nutzers
-	 * sicherzustellen, dass die CSV-Datei auch nur Zahlen enthält, die korrekt
-	 * in {@code double} umgewandelt werden können. Zellen für die die
-	 * Umwandlung fehlschlägt werden mit 0.0 befüllt.
+	 * Die Zeilen der Eingabedatei werden anhand der Zeichenkette {@code separator}
+	 * in einzelne Teile aufgetrennt. {@code separator} wird als regulärer Ausdruck
+	 * interpretiert (siehe {@link String#split(String)}).
+	 * <p>
+	 * Jeder Teilstring wird mit {@link Double#parseDouble(String)} in
+	 * {@code double} umgeformt. Es liegt in der Verantwortung des Nutzers,
+	 * sicherzustellen, dass die Eingabedatei nur Zahlen enthält, die korrekt
+	 * in {@code double} umgewandelt werden können. Zellen, für die die
+	 * Umwandlung fehlschlägt, werden mit 0.0 befüllt.
 	 * <p>
 	 * Die Methode unterliegt denselben Einschränkungen wie
 	 * {@link #loadCsv(String, char, boolean, Charset)}.
 	 *
 	 * @param source Die Quelle der CSV-Daten.
-	 * @param separator Das verwendete Trennzeichen.
+	 * @param separator Ein Trennzeichen oder ein regulärer Ausdruck.
 	 * @param skipFirst Ob die erste Zeile übersprungen werden soll.
 	 * @param charset Die zu verwendende Zeichenkodierung.
 	 * @return Ein Array mit den Daten als {@code String}s.
 	 */
-	public static double[][] loadValues( String source, char separator, boolean skipFirst, Charset charset ) {
+	public static double[][] loadValues( String source, String separator, boolean skipFirst, Charset charset ) {
 		int n = skipFirst ? 1 : 0;
 		List<String> lines = loadLines(source, charset);
 		return lines.stream().skip(n).map(
 			( line ) -> Arrays
-				.stream(line.split(Character.toString(separator)))
+				//.stream(line.split(Character.toString(separator)))
+				.stream(line.split(separator))
 				.mapToDouble(
 					( value ) -> {
 						try {

src/main/java/schule/ngb/zm/util/io/FontLoader.java

@@ -1,5 +1,6 @@
 package schule.ngb.zm.util.io;
 
+import schule.ngb.zm.util.Cache;
 import schule.ngb.zm.util.Log;
 import schule.ngb.zm.util.Validator;
 
@@ -9,11 +10,12 @@ import java.awt.Image;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.MalformedURLException;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
- * Eine Helferklasse mit Klassenmethoden, um Schriftarten zu laden.
+ * Eine Hilfsklasse mit Klassenmethoden, um Schriftarten zu laden.
  * <p>
  * Schriftarten können von verschiedenen Quellen geladen werden. Schriftarten,
  * die aus Dateien geladen wurden, werden in einem internen Cache gespeichert
@@ -22,7 +24,7 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class FontLoader {
 
-	private static final Map<String, Font> fontCache = new ConcurrentHashMap<>();
+	private static final Cache<String, Font> fontCache = Cache.newSoftCache();
 
 	/**
 	 * Lädt eine Schrift aus einer Datei.
@@ -61,8 +63,8 @@ public class FontLoader {
 	}
 
 	public static Font loadFont( String name, String source ) {
-		Validator.requireNotNull(source, "Font source may not be null");
-		Validator.requireNotEmpty(source, "Font source may not be empty.");
+		Validator.requireNotNull(source, "source");
+		Validator.requireNotEmpty(source, "source");
 
 		if( fontCache.containsKey(name) ) {
 			LOG.trace("Retrieved font <%s> from font cache.", name);
@@ -90,10 +92,12 @@ public class FontLoader {
 				//ge.registerFont(font);
 			}
 			LOG.debug("Loaded custom font from source <%s>.", source);
+		} catch( MalformedURLException muex ) {
+			LOG.warn("Could not find font resource for <%s>", source);
 		} catch( IOException ioex ) {
-			LOG.error(ioex, "Error loading custom font file from source <%s>.", source);
+			LOG.warn(ioex, "Error loading custom font file from source <%s>.", source);
 		} catch( FontFormatException ffex ) {
-			LOG.error(ffex, "Error creating custom font from source <%s>.", source);
+			LOG.warn(ffex, "Error creating custom font from source <%s>.", source);
 		}
 
 		return font;

src/main/java/schule/ngb/zm/util/io/ImageLoader.java

@@ -1,6 +1,7 @@
 package schule.ngb.zm.util.io;
 
 import schule.ngb.zm.util.Log;
+import schule.ngb.zm.util.Cache;
 import schule.ngb.zm.util.Validator;
 
 import javax.imageio.ImageIO;
@@ -15,11 +16,10 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.ref.SoftReference;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.net.MalformedURLException;
 
 /**
- * Eine Helferklasse mit Klassenmethoden, um Bilder zu laden.
+ * Eine Hilfsklasse mit Klassenmethoden, um Bilder zu laden.
  * <p>
  * Bilder können von verschiedenen Quellen als {@link Image} geladen werden. Die
  * Objekte werden in einem internen Cache gespeichert und nachfolgende Versuche,
@@ -29,9 +29,7 @@ public final class ImageLoader {
 
 	public static boolean caching = true;
 
-	private static final Map<String, SoftReference<BufferedImage>> imageCache = new ConcurrentHashMap<>();
-
-	private static final SoftReference<BufferedImage> NOCACHE = new SoftReference<>(null);
+	private static final Cache<String, BufferedImage> imageCache = Cache.newSoftCache();
 
 	/**
 	 * Lädt ein Bild von der angegebenen Quelle {@code source}.
@@ -70,11 +68,11 @@ public final class ImageLoader {
 	 * @return
 	 */
 	public static BufferedImage loadImage( String source, boolean caching ) {
-		Validator.requireNotNull(source, "Image source may not be null");
-		Validator.requireNotEmpty(source, "Image source may not be empty.");
+		Validator.requireNotNull(source, "source");
+		Validator.requireNotEmpty(source, "source");
 
-		if( caching && isCached(source) ) {
-			return getCache(source);
+		if( caching && imageCache.containsKey(source) ) {
+			return imageCache.get(source);
 		}
 
 		BufferedImage img = null;
@@ -85,10 +83,12 @@ public final class ImageLoader {
 			img = ImageIO.read(in);
 
 			if( caching && img != null ) {
-				putCache(source, img);
+				imageCache.put(source, img);
 			}
+		} catch( MalformedURLException muex ) {
+			LOG.warn("Could not find image resource for <%s>", source);
 		} catch( IOException ioex ) {
-			LOG.error(ioex, "Error loading image file from source <%s>.", source);
+			LOG.warn(ioex, "Error loading image file from source <%s>.", source);
 		}
 		return img;
 	}
@@ -113,7 +113,7 @@ public final class ImageLoader {
 	public static boolean preloadImage( String name, String source ) {
 		BufferedImage img = loadImage(source, true);
 		if( img != null ) {
-			putCache(name, img);
+			imageCache.put(name, img);
 			return true;
 		}
 		return false;
@@ -134,7 +134,7 @@ public final class ImageLoader {
 	 * @param img ZU speicherndes Bild.
 	 */
 	public static void preloadImage( String name, BufferedImage img ) {
-		putCache(name, img);
+		imageCache.put(name, img);
 	}
 
 	/**
@@ -145,8 +145,7 @@ public final class ImageLoader {
 	 *    {@code false}.
 	 */
 	public static boolean isCached( String name ) {
-		SoftReference<BufferedImage> imgRef = imageCache.get(name);
-		return imgRef != null && imgRef != NOCACHE && imgRef.get() != null;
+		return imageCache.containsKey(name);
 	}
 
 	/**
@@ -159,30 +158,6 @@ public final class ImageLoader {
 		imageCache.remove(name);
 	}
 
-	/**
-	 * Speichert ein Bild als {@link SoftReference} im Cache.
-	 *
-	 * @param name Name des Bildes im Zwischenspeicher.
-	 * @param img Das zu speichernde Bild.
-	 */
-	private static void putCache( final String name, final BufferedImage img ) {
-		imageCache.put(name, new SoftReference<>(img));
-	}
-
-	/**
-	 * Holt ein Bild aus dem Cache.
-	 * <p>
-	 * Prüft nicht, ob ein Bild vorhanden ist. Dies sollte vom Aufrufenden
-	 * übernommen werden, da sonst eine {@link NullPointerException} erzeugt
-	 * werden kann.
-	 *
-	 * @param name
-	 * @return
-	 */
-	private static BufferedImage getCache( final String name ) {
-		return imageCache.get(name).get();
-	}
-
 	/**
 	 * Deaktiviert den Cache für die angegebene Quelle.
 	 * <p>
@@ -192,14 +167,14 @@ public final class ImageLoader {
 	 *
 	 * @param name Die Quelle des Bildes.
 	 */
-	public static void preventCache( final String name ) {
-		imageCache.put(name, NOCACHE);
+	public static void disableCache( final String name ) {
+		imageCache.disableCache(name);
 	}
 
 	/**
 	 * Leer den Cache und löschte alle bisher gespeicherten Bilder.
 	 * <p>
-	 * Auch vorher mit {@link #preventCache(String)} verhinderte Caches werden
+	 * Auch vorher mit {@link #disableCache(String)} verhinderte Caches werden
 	 * gelöscht und müssen neu gesetzt werden.
 	 */
 	public static void clearCache() {
@@ -346,12 +321,8 @@ public final class ImageLoader {
 	 * @throws IOException          Falls es einen Fehler beim Speichern gab.
 	 */
 	public static void saveImage( BufferedImage image, File file, boolean overwriteIfExists ) throws IOException {
-		if( image == null ) {
-			throw new NullPointerException("Image may not be <null>.");
-		}
-		if( file == null ) {
-			throw new NullPointerException("File may not be <null>.");
-		}
+		Validator.requireNotNull(image, "image");
+		Validator.requireNotNull(file, "file");
 
 		if( file.isFile() ) {
 			// Datei existiert schon

src/main/java/schule/ngb/zm/util/io/ResourceStreamProvider.java

@@ -13,7 +13,7 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 
 /**
- * Helferklasse, um {@link InputStream}s für Ressourcen zu erhalten.
+ * Hilfsklasse, um {@link InputStream}s für Ressourcen zu erhalten.
  */
 @SuppressWarnings("unused")
 public class ResourceStreamProvider {
@@ -47,8 +47,8 @@ public class ResourceStreamProvider {
 	 *                                  einer bestehenden Ressource.
 	 */
 	public static URL getResourceURL( String source ) throws NullPointerException, IllegalArgumentException, IOException {
-		Validator.requireNotNull(source, "Resource source may not be null");
-		Validator.requireNotEmpty(source, "Resource source may not be empty.");
+		Validator.requireNotNull(source, "source");
+		Validator.requireNotEmpty(source, "source");
 
 		// Ist source ein valider Dateipfad?
 		File file = new File(source);

src/main/java/schule/ngb/zm/util/io/package-info.java

@@ -1,5 +1,5 @@
 /**
- * Dieses Paket enthält Helferklassen, um Ressourcen aus verschiedenen Quellen
+ * Dieses Paket enthält Hilfsklassen, um Ressourcen aus verschiedenen Quellen
  * zu laden.
  */
 package schule.ngb.zm.util.io;

src/main/java/schule/ngb/zm/util/package-info.java

@@ -1,4 +1,4 @@
 /**
- * Dieses Paket enthält Helferklassen für verschiedene Einsatzzwecke.
+ * Dieses Paket enthält Hilfsklassen für verschiedene Einsatzzwecke.
  */
 package schule.ngb.zm.util;

src/main/java/schule/ngb/zm/util/tasks/package-info.java

@@ -1,5 +1,5 @@
 /**
- * Dieses Paket enthält Helferklassen zur Verarbeitung paralleler Aufgaben
+ * Dieses Paket enthält Hilfsklassen zur Ausführung paralleler Aufgaben
  * innerhalb der Zeichenmaschine.
  */
 package schule.ngb.zm.util.tasks;

src/main/resources/overview.html

@@ -2,7 +2,7 @@
 <BODY>
 Die Zeichenmaschine
 <p>
-	<h2>Die Zeichenmaschine</h2>
+	<h1>Die Zeichenmaschine</h1>
 
 	@author J. Neugebauer
 </BODY>

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

@@ -252,4 +252,18 @@ class ColorTest {
 	void darker() {
 	}
 
+	@Test
+	void compare() {
+		assertEquals(1.0, Color.RED.compare(Color.RED), 0.0001);
+		assertEquals(1.0, Color.BLUE.compare(Color.BLUE), 0.0001);
+		assertEquals(1.0, Color.WHITE.compare(Color.WHITE), 0.0001);
+		assertEquals(1.0, Color.BLACK.compare(Color.BLACK), 0.0001);
+
+
+		assertEquals(0.0, Color.BLACK.compare(Color.WHITE), 0.0001);
+		assertEquals(0.0, Color.WHITE.compare(Color.BLACK), 0.0001);
+
+		assertEquals(0.5, Color.GRAY.compare(Color.BLACK), 0.01);
+	}
+
 }

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

@@ -0,0 +1,51 @@
+package schule.ngb.zm;
+
+
+import schule.ngb.zm.layers.DrawingLayer;
+import schule.ngb.zm.util.Log;
+
+public class Testmaschine extends Zeichenmaschine {
+
+	static {
+		Log.enableGlobalDebugging();
+	}
+
+	private DrawingLayer gridLayer;
+
+	public Testmaschine() {
+		this(400, 400);
+	}
+
+	public Testmaschine( int width, int height ) {
+		super(width, height, "Testmaschine", false);
+	}
+
+	@Override
+	public void settings() {
+		gridLayer = new DrawingLayer(getWidth(), getHeight());
+		this.getCanvas().addLayer(1, gridLayer);
+		setGrid(50, 10);
+	}
+
+	public void setGrid( int majorGrid, int minorGrid ) {
+		gridLayer.clear();
+
+		gridLayer.clear(LIGHTGRAY);
+		gridLayer.setStrokeColor(LIGHTGRAY.darker(20));
+		for( int i = 0; i < getWidth(); i += minorGrid ) {
+			gridLayer.line(i, 0, i, gridLayer.getHeight());
+		}
+		for( int i = 0; i < getHeight(); i += minorGrid ) {
+			gridLayer.line(0, i, gridLayer.getWidth(), i);
+		}
+
+		gridLayer.setStrokeColor(LIGHTGRAY.darker(50));
+		for( int i = 0; i < getWidth(); i += majorGrid ) {
+			gridLayer.line(i, 0, i, gridLayer.getHeight());
+		}
+		for( int i = 0; i < getHeight(); i += majorGrid ) {
+			gridLayer.line(0, i, gridLayer.getWidth(), i);
+		}
+	}
+
+}

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

@@ -0,0 +1,71 @@
+package schule.ngb.zm;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import schule.ngb.zm.layers.DrawingLayer;
+import schule.ngb.zm.util.io.ImageLoader;
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static schule.ngb.zm.util.test.ImageAssertions.assertEquals;
+import static schule.ngb.zm.util.test.ImageAssertions.setSaveDiffImageOnFail;
+
+public class TestmaschineTest {
+
+	private static Testmaschine tm;
+
+	private static DrawingLayer drawing;
+
+	@BeforeAll
+	static void beforeAll() {
+		setSaveDiffImageOnFail(true);
+
+		tm = new Testmaschine();
+		drawing = tm.getDrawingLayer();
+		assertNotNull(drawing);
+	}
+
+	@AfterAll
+	static void afterAll() {
+		tm.exit();
+	}
+
+	@BeforeEach
+	void setUp() {
+		drawing.clear();
+	}
+
+	@Test
+	void testSaveDiffImage() {
+		drawing.noStroke();
+		drawing.setAnchor(Constants.NORTHWEST);
+		drawing.setFillColor(Constants.BLUE);
+		drawing.rect(0, 0, 400, 400);
+		drawing.setFillColor(Constants.RED);
+		drawing.rect(100, 100, 200, 200);
+
+		BufferedImage img1 = ImageLoader.createImage(400, 400);
+		Graphics2D graphics = img1.createGraphics();
+
+		graphics.setColor(Constants.BLUE.getJavaColor());
+		graphics.fillRect(0, 0, 400, 400);
+		graphics.setColor(Constants.RED.getJavaColor());
+		graphics.fillRect(100, 100, 200, 200);
+
+		assertEquals(drawing.buffer, drawing.buffer);
+		assertEquals(ImageLoader.copyImage(drawing.buffer), drawing.buffer);
+		assertEquals(img1, drawing.buffer);
+		assertEquals(img1, tm.getImage());
+	}
+
+	@Test
+	void testGrid() {
+//		tm.setGrid(50, 10);
+		tm.delay(2000);
+	}
+
+}

src/test/java/schule/ngb/zm/anim/AnimationGroupsTest.java

@@ -0,0 +1,96 @@
+package schule.ngb.zm.anim;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import schule.ngb.zm.Color;
+import schule.ngb.zm.Testmaschine;
+import schule.ngb.zm.Zeichenmaschine;
+import schule.ngb.zm.layers.ShapesLayer;
+import schule.ngb.zm.shapes.Circle;
+import schule.ngb.zm.shapes.Shape;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class AnimationGroupsTest {
+
+	private static Testmaschine zm;
+
+	private static ShapesLayer shapes;
+
+	@BeforeAll
+	static void beforeAll() {
+		zm = new Testmaschine();
+		shapes = zm.getShapesLayer();
+		assertNotNull(shapes);
+	}
+
+	@AfterAll
+	static void afterAll() {
+		zm.exit();
+	}
+
+	@BeforeEach
+	void setUp() {
+		shapes.removeAll();
+	}
+
+	@Test
+	void animationGroup() {
+		Shape s = new Circle(0, 0, 10);
+		shapes.add(s);
+
+		Animation<Shape> anims = new AnimationGroup<>(
+			500,
+			Arrays.asList(
+				new MoveAnimation(s, 200, 200, 2000, Easing.DEFAULT_EASING),
+				new FillAnimation(s, Color.GREEN, 1000, Easing.sineIn())
+			)
+		);
+		Animations.playAndWait(anims);
+		assertEquals(200, s.getX());
+		assertEquals(200, s.getY());
+		assertEquals(Color.GREEN, s.getFillColor());
+	}
+
+	@Test
+	void animationSequence() {
+		Shape s = new Circle(0, 0, 10);
+		shapes.add(s);
+
+		Animation<Shape> anims = new AnimationSequence<>(
+			Arrays.asList(
+				new CircleAnimation(s, 200, 0, 90, false, 1000, Easing::rushIn),
+				new CircleAnimation(s, 200, 400, 90, 1000, Easing::rushOut),
+				new CircleAnimation(s, 200, 400, 90, false, 1000, Easing::rushIn),
+				new CircleAnimation(s, 200, 0, 90, 1000, Easing::rushOut)
+			)
+		);
+		Animations.playAndWait(anims);
+		assertEquals(0, s.getX());
+		assertEquals(0, s.getY());
+	}
+
+	@Test
+	void animationSequenceContinous() {
+		Shape s = new Circle(0, 0, 10);
+		shapes.add(s);
+
+		Animation<Shape> anims = new ContinousAnimation<>(new AnimationSequence<>(
+			Arrays.asList(
+				new CircleAnimation(s, 200, 0, 90, false, 1000, Easing::rushIn),
+				new CircleAnimation(s, 200, 400, 90, 1000, Easing::rushOut),
+				new CircleAnimation(s, 200, 400, 90, false, 1000, Easing::rushIn),
+				new CircleAnimation(s, 200, 0, 90, 1000, Easing::rushOut)
+			)
+		), false);
+		Animations.playAndWait(anims);
+		zm.delay(8000);
+		anims.stop();
+	}
+
+}

src/test/java/schule/ngb/zm/anim/AnimationTest.java

@@ -0,0 +1,75 @@
+package schule.ngb.zm.anim;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import schule.ngb.zm.Testmaschine;
+import schule.ngb.zm.layers.ShapesLayer;
+import schule.ngb.zm.shapes.Circle;
+import schule.ngb.zm.shapes.Shape;
+import schule.ngb.zm.util.test.TestEnv;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class AnimationTest {
+
+	private static Testmaschine zm;
+
+	private static ShapesLayer shapes;
+
+	@BeforeAll
+	static void beforeAll() {
+		zm = new Testmaschine();
+		shapes = zm.getShapesLayer();
+		assertNotNull(shapes);
+	}
+
+	@AfterAll
+	static void afterAll() {
+		zm.exit();
+	}
+
+	@BeforeEach
+	void setUp() {
+		shapes.removeAll();
+	}
+
+	@Test
+	void circleAnimation() {
+		Shape s = new Circle(zm.getWidth()/4.0, zm.getHeight()/2.0, 10);
+		shapes.add(s);
+
+		CircleAnimation anim = new CircleAnimation(s, zm.getWidth()/2.0, zm.getHeight()/2.0, 360, true, 3000, Easing::linear);
+		Animations.playAndWait(anim);
+		assertEquals(zm.getWidth()/4.0, s.getX());
+		assertEquals(zm.getHeight()/2.0, s.getY());
+	}
+
+	@Test
+	void fadeAnimation() {
+		Shape s = new Circle(zm.getWidth()/4.0, zm.getHeight()/2.0, 10);
+		s.setFillColor(s.getFillColor(), 0);
+		s.setStrokeColor(s.getStrokeColor(), 0);
+		shapes.add(s);
+
+		Animation<Shape> anim = new FadeAnimation(s, 255, 1000);
+		Animations.playAndWait(anim);
+		assertEquals(s.getFillColor().getAlpha(), 255);
+	}
+
+	@Test
+	void continousAnimation() {
+		Shape s = new Circle(zm.getWidth()/4, zm.getHeight()/2, 10);
+		shapes.add(s);
+
+		ContinousAnimation anim = new ContinousAnimation(
+			new CircleAnimation(s, zm.getWidth()/2, zm.getHeight()/2, 360, true, 1000, Easing::linear)
+		);
+		Animations.play(anim);
+		zm.delay(3000);
+		anim.stop();
+	}
+
+}

src/test/java/schule/ngb/zm/layers/DrawingLayerTest.java

@@ -0,0 +1,30 @@
+package schule.ngb.zm.layers;
+
+import org.junit.jupiter.api.Test;
+import schule.ngb.zm.Constants;
+import schule.ngb.zm.Zeichenmaschine;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DrawingLayerTest {
+
+	@Test
+	void imageRotateAndScale() {
+		Zeichenmaschine zm = new Zeichenmaschine();
+		zm.getDrawingLayer().imageRotateAndScale(
+			"WitchCraftIcons_122_t.PNG",
+			50, 100,
+			90,
+			300, 200,
+			Constants.NORTHWEST
+		);
+		zm.redraw();
+
+		try {
+			Thread.sleep(4000);
+		} catch( InterruptedException e ) {
+			throw new RuntimeException(e);
+		}
+	}
+
+}

src/test/java/schule/ngb/zm/particles/ParticleExample.java

@@ -0,0 +1,158 @@
+package schule.ngb.zm.particles;
+
+import schule.ngb.zm.*;
+import schule.ngb.zm.layers.DrawableLayer;
+import schule.ngb.zm.layers.DrawingLayer;
+
+import java.awt.Graphics2D;
+
+public class ParticleExample extends Testmaschine {
+
+	public static void main( String[] args ) {
+		new ParticleExample();
+	}
+
+	public ParticleExample() {
+		super();
+	}
+
+	ParticleEmitter pe1, pe2, pe3;
+
+	Rocket r;
+
+	public void setup() {
+		getLayer(DrawingLayer.class).hide();
+		background.setColor(0);
+		drawing.noStroke();
+		drawing.setFillColor(WHITE);
+		for( int i = 0; i < 1000; i++ ) {
+			drawing.point(random(0, canvasWidth), random(0, canvasHeight));
+		}
+
+		pe1 = new ParticleEmitter(
+			100, 100, 50, 5,
+			// new BasicParticleFactory(PINK, BLUE)
+			new GenericParticleFactory<Particle>(() -> {
+				return new Particle() {
+					@Override
+					public void draw( Graphics2D graphics ) {
+						graphics.setColor(Color.MAGENTA.getJavaColor());
+						graphics.rotate(Constants.radians(45), (int) position.x, (int) position.y);
+						graphics.drawRect((int) position.x - 3, (int) position.y - 3, 6, 6);
+						graphics.rotate(Constants.radians(-45), (int) position.x, (int) position.y);
+					}
+				};
+			})
+		);
+		pe1.randomness = .2;
+		pe1.angle = 45;
+		pe1.strength = 200;
+
+
+		pe2 = new ParticleEmitter(
+			300, 300, 50, 10,
+			new GenericParticleFactory(() -> new StarParticle(RED, new Color(BLUE, 55)))
+			//new GenericParticleFactory(StarParticle.class, RED, new Color(BLUE, 55))
+		);
+		pe2.direction = NORTH.asVector().scale(100);
+		pe2.randomness = .8;
+		pe2.angle = 90;
+		pe2.strength = 200;
+
+
+		pe3 = new ParticleEmitter(
+			100, 400, 20, 8,
+			new BasicParticleFactory(YELLOW, RED)
+		);
+		pe3.direction = SOUTH.asVector();
+		pe3.randomness = .33;
+		pe3.angle = 30;
+
+		DrawableLayer drawables = new DrawableLayer();
+		addLayer(drawables);
+		drawables.add(pe1, pe2, pe3);
+
+		pe1.start();
+		pe2.start();
+		pe3.start();
+
+		r = new Rocket(200, 400);
+		drawables.add(r);
+		r.start();
+	}
+
+	@Override
+	public void update( double delta ) {
+		pe1.update(delta);
+		pe2.update(delta);
+		pe3.update(delta);
+		pe3.position.add(NORTH.asVector().scale(Constants.map(runtime, 0, 1000, 0, 10) * delta));
+
+		if( r.isActive() ) {
+			r.update(delta);
+		}
+	}
+
+	class Rocket extends PhysicsObject implements Drawable {
+
+		ParticleEmitter trail;
+
+		private boolean starting = false;
+
+		private double acc = 4;
+
+		public Rocket( double x, double y ) {
+			super(new Vector(x, y));
+			trail = new ParticleEmitter(
+				x, y, 30, 6,
+				new BasicParticleFactory(YELLOW, RED)
+			);
+			trail.direction = SOUTH.asVector();
+			trail.randomness = .33;
+			trail.angle = 30;
+			trail.position = this.position;
+		}
+
+		public void start() {
+			starting = true;
+			trail.start();
+		}
+
+		@Override
+		public boolean isActive() {
+			return starting;
+		}
+
+		@Override
+		public boolean isVisible() {
+			return true;
+		}
+
+		@Override
+		public void update( double delta ) {
+			super.update(delta);
+			if( this.acceleration.lengthSq() < acc * acc ) {
+				this.accelerate(NORTHWEST.asVector().scale(acc));
+			}
+
+			trail.update(delta);
+		}
+
+		@Override
+		public void draw( Graphics2D graphics ) {
+			graphics.rotate(-Constants.radians(velocity.angle() + 180), position.getIntX(), position.getIntY());
+			trail.draw(graphics);
+
+			graphics.setColor(WHITE.getJavaColor());
+			graphics.fillRect(position.getIntX() - 6, position.getIntY() - 32, 12, 32);
+			graphics.fillPolygon(
+				new int[]{position.getIntX() - 6, position.getIntX(), position.getIntX() + 6},
+				new int[]{position.getIntY() - 32, position.getIntY() - 40, position.getIntY() - 32},
+				3
+			);
+			graphics.rotate(Constants.radians(velocity.angle() + 180), position.getIntX(), position.getIntY());
+		}
+
+	}
+
+}

src/test/java/schule/ngb/zm/util/FileLoaderTest.java

@@ -72,10 +72,10 @@ class FileLoaderTest {
 			{2.1,2.2,2.3},
 			{3.1,3.2,3.3}
 		};
-		csv = FileLoader.loadValues("data_comma.csv", ',', true);
+		csv = FileLoader.loadValues("data_comma.csv", ",", true);
 		assertArrayEquals(data, csv);
 
-		csv = FileLoader.loadValues("data_semicolon_latin.csv", ';', true, FileLoader.ISO_8859_1);
+		csv = FileLoader.loadValues("data_semicolon_latin.csv", ";", true, FileLoader.ISO_8859_1);
 		assertArrayEquals(data, csv);
 	}
 

src/test/java/schule/ngb/zm/util/abi/BinarySearchTree.java

@@ -0,0 +1,262 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse BinarySearchTree<ContentType>
+ * </p>
+ * <p>
+ * Mithilfe der generischen Klasse BinarySearchTree koennen beliebig viele
+ * Objekte in einem Binaerbaum (binaerer Suchbaum) entsprechend einer
+ * Ordnungsrelation verwaltet werden. <br />
+ * Ein Objekt der Klasse stellt entweder einen leeren binaeren Suchbaum dar oder
+ * verwaltet ein Inhaltsobjekt sowie einen linken und einen rechten Teilbaum,
+ * die ebenfalls Objekte der Klasse BinarySearchTree sind.<br />
+ * Die Klasse der Objekte, die in dem Suchbaum verwaltet werden sollen, muss
+ * das generische Interface ComparableContent implementieren. Dabei muss durch
+ * Ueberschreiben der drei Vergleichsmethoden isLess, isEqual, isGreater (s.
+ * Dokumentation des Interfaces) eine eindeutige Ordnungsrelation festgelegt
+ * sein. <br />
+ * Alle Objekte im linken Teilbaum sind kleiner als das Inhaltsobjekt des
+ * binaeren Suchbaums. Alle Objekte im rechten Teilbaum sind groesser als das
+ * Inhaltsobjekt des binaeren Suchbaums. Diese Bedingung gilt (rekursiv) auch in
+ * beiden Teilbaeumen. <br />
+ * Hinweis: In dieser Version wird die Klasse BinaryTree nicht benutzt.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_03 2017-11-28
+ */
+public class BinarySearchTree<ContentType extends ComparableContent<ContentType>> {
+
+	/* --------- Anfang der privaten inneren Klasse -------------- */
+
+	/**
+	 * Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum
+	 * null ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
+	 * nicht-null-Teilbaeume hat.
+	 */
+	private class BSTNode<CT extends ComparableContent<CT>> {
+
+		private CT content;
+		private BinarySearchTree<CT> left, right;
+
+		public BSTNode(CT pContent) {
+			// Der Knoten hat einen linken und rechten Teilbaum, die
+			// beide von null verschieden sind. Also hat ein Blatt immer zwei
+			// leere Teilbaeume unter sich.
+			this.content = pContent;
+			left = new BinarySearchTree<CT>();
+			right = new BinarySearchTree<CT>();
+		}
+
+	}
+
+	/* ----------- Ende der privaten inneren Klasse -------------- */
+
+	private BSTNode<ContentType> node;
+
+	/**
+	 * Der Konstruktor erzeugt einen leeren Suchbaum.
+	 */
+	public BinarySearchTree() {
+		this.node = null;
+	}
+
+	/**
+	 * Diese Anfrage liefert den Wahrheitswert true, wenn der Suchbaum leer ist,
+	 * sonst liefert sie den Wert false.
+	 *
+	 * @return true, wenn der binaere Suchbaum leer ist, sonst false
+	 *
+	 */
+	public boolean isEmpty() {
+		return this.node == null;
+	}
+
+	/**
+	 * Falls der Parameter null ist, geschieht nichts.<br />
+	 * Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
+	 * pContent uebereinstimmendes Objekt im geordneten binaeren Suchbau
+	 * enthalten ist, passiert nichts. <br />
+	 * Achtung: hier wird davon ausgegangen, dass isEqual genau dann true
+	 * liefert, wenn isLess und isGreater false liefern. <br />
+	 * Andernfalls (isLess oder isGreater) wird das Objekt pContent entsprechend
+	 * der vorgegebenen Ordnungsrelation in den BinarySearchTree eingeordnet.
+	 *
+	 * @param pContent
+	 *            einzufuegendes Objekt vom Typ ContentType
+	 *
+	 */
+	public void insert(ContentType pContent) {
+		if (pContent != null) {
+			if (isEmpty()) {
+				this.node = new BSTNode<ContentType>(pContent);
+			} else if (pContent.isLess(this.node.content)) {
+				this.node.left.insert(pContent);
+			} else if(pContent.isGreater(this.node.content)) {
+				this.node.right.insert(pContent);
+			}
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert den linken Teilbaum des binaeren Suchbaumes. <br />
+	 * Wenn er leer ist, wird null zurueckgegeben.
+	 *
+	 * @return den linken Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
+	 *         bzw. null, wenn der Suchbaum leer ist
+	 *
+	 */
+	public BinarySearchTree<ContentType> getLeftTree() {
+		if (this.isEmpty()) {
+			return null;
+		} else {
+			return this.node.left;
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert das Inhaltsobjekt des Suchbaumes. Wenn der Suchbaum
+	 * leer ist, wird null zurueckgegeben.
+	 *
+	 * @return das Inhaltsobjekt vom Typ ContentType bzw. null, wenn der aktuelle
+	 *         Suchbaum leer ist
+	 *
+	 */
+	public ContentType getContent() {
+		if (this.isEmpty()) {
+			return null;
+		} else {
+			return this.node.content;
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert den rechten Teilbaum des binaeren Suchbaumes. <br />
+	 * Wenn er leer ist, wird null zurueckgegeben.
+	 *
+	 * @return den rechten Teilbaum (Objekt vom Typ BinarySearchTree<ContentType>)
+	 *         bzw. null, wenn der aktuelle Suchbaum leer ist
+	 *
+	 */
+	public BinarySearchTree<ContentType> getRightTree() {
+		if (this.isEmpty()) {
+			return null;
+		} else {
+			return this.node.right;
+		}
+	}
+
+	/**
+	 * Falls ein bezueglich der verwendeten Vergleichsmethode mit
+	 * pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten
+	 * ist, wird dieses entfernt. Falls der Parameter null ist, aendert sich
+	 * nichts.
+	 *
+	 * @param pContent
+	 *            zu entfernendes Objekt vom Typ ContentType
+	 *
+	 */
+	public void remove(ContentType pContent) {
+		if (isEmpty() || pContent == null ) {
+			// Abbrechen, da kein Element zum entfernen vorhanden ist.
+		  return;
+		}
+
+		if (pContent.isLess(node.content)) {
+			// Element ist im linken Teilbaum zu loeschen.
+			node.left.remove(pContent);
+		} else if (pContent.isGreater(node.content)) {
+			// Element ist im rechten Teilbaum zu loeschen.
+			node.right.remove(pContent);
+		} else {
+			// Element ist gefunden.
+			if (node.left.isEmpty()) {
+				if (node.right.isEmpty()) {
+					// Es gibt keinen Nachfolger.
+					node = null;
+				} else {
+					// Es gibt nur rechts einen Nachfolger.
+					node = getNodeOfRightSuccessor();
+				}
+			} else if (node.right.isEmpty()) {
+				// Es gibt nur links einen Nachfolger.
+				node = getNodeOfLeftSuccessor();
+			} else {
+				// Es gibt links und rechts einen Nachfolger.
+				if (getNodeOfRightSuccessor().left.isEmpty()) {
+					// Der rechte Nachfolger hat keinen linken Nachfolger.
+					node.content = getNodeOfRightSuccessor().content;
+					node.right = getNodeOfRightSuccessor().right;
+				} else {
+					BinarySearchTree<ContentType> previous = node.right
+							.ancestorOfSmallRight();
+					BinarySearchTree<ContentType> smallest = previous.node.left;
+					this.node.content = smallest.node.content;
+					previous.remove(smallest.node.content);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Falls ein bezueglich der verwendeten Vergleichsmethode isEqual mit
+	 * pContent uebereinstimmendes Objekt im binaeren Suchbaum enthalten ist,
+	 * liefert die Anfrage dieses, ansonsten wird null zurueckgegeben. <br />
+	 * Falls der Parameter null ist, wird null zurueckgegeben.
+	 *
+	 * @param pContent
+	 *            zu suchendes Objekt vom Typ ContentType
+	 * @return das gefundene Objekt vom Typ ContentType, bei erfolgloser Suche null
+	 *
+	 */
+	public ContentType search(ContentType pContent) {
+		if (this.isEmpty() || pContent == null) {
+			// Abbrechen, da es kein Element zu suchen gibt.
+			return null;
+		} else {
+			ContentType content = this.getContent();
+			if (pContent.isLess(content)) {
+				// Element wird im linken Teilbaum gesucht.
+				return this.getLeftTree().search(pContent);
+			} else if (pContent.isGreater(content)) {
+				// Element wird im rechten Teilbaum gesucht.
+				return this.getRightTree().search(pContent);
+			} else if (pContent.isEqual(content)) {
+				// Element wurde gefunden.
+			  return content;
+			} else {
+			  // Dieser Fall sollte nicht auftreten.
+				return null;
+			}
+		}
+	}
+
+	/* ----------- Weitere private Methoden -------------- */
+
+	/**
+	 * Die Methode liefert denjenigen Baum, dessen linker Nachfolger keinen linken
+	 * Nachfolger mehr hat. Es ist also spaeter moeglich, in einem Baum im
+	 * rechten Nachfolger den Vorgaenger des linkesten Nachfolgers zu finden.
+	 *
+	 */
+	private BinarySearchTree<ContentType> ancestorOfSmallRight() {
+		if (getNodeOfLeftSuccessor().left.isEmpty()) {
+			return this;
+		} else {
+			return node.left.ancestorOfSmallRight();
+		}
+	}
+
+	private BSTNode<ContentType> getNodeOfLeftSuccessor() {
+		return node.left.node;
+	}
+
+	private BSTNode<ContentType> getNodeOfRightSuccessor() {
+		return node.right.node;
+	}
+
+}

src/test/java/schule/ngb/zm/util/abi/BinaryTree.java

@@ -0,0 +1,212 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse BinaryTree<ContentType>
+ * </p>
+ * <p>
+ * Mithilfe der generischen Klasse BinaryTree koennen beliebig viele
+ * Inhaltsobjekte vom Typ ContentType in einem Binaerbaum verwaltet werden. Ein
+ * Objekt der Klasse stellt entweder einen leeren Baum dar oder verwaltet ein
+ * Inhaltsobjekt sowie einen linken und einen rechten Teilbaum, die ebenfalls
+ * Objekte der generischen Klasse BinaryTree sind.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_03 2014-03-01
+ */
+public class BinaryTree<ContentType> {
+
+	/* --------- Anfang der privaten inneren Klasse -------------- */
+
+	/**
+	 * Durch diese innere Klasse kann man dafuer sorgen, dass ein leerer Baum
+	 * null ist, ein nicht-leerer Baum jedoch immer eine nicht-null-Wurzel sowie
+	 * nicht-null-Teilbaeume, ggf. leere Teilbaeume hat.
+	 */
+	private class BTNode<CT> {
+
+		private CT content;
+		private BinaryTree<CT> left, right;
+
+		public BTNode(CT pContent) {
+			// Der Knoten hat einen linken und einen rechten Teilbaum, die
+			// beide von null verschieden sind. Also hat ein Blatt immer zwei
+			// leere Teilbaeume unter sich.
+			this.content = pContent;
+			left = new BinaryTree<CT>();
+			right = new BinaryTree<CT>();
+		}
+
+	}
+
+	/* ----------- Ende der privaten inneren Klasse -------------- */
+
+	private BTNode<ContentType> node;
+
+	/**
+	 * Nach dem Aufruf des Konstruktors existiert ein leerer Binaerbaum.
+	 */
+	public BinaryTree() {
+		this.node = null;
+	}
+
+	/**
+	 * Wenn der Parameter pContent ungleich null ist, existiert nach dem Aufruf
+	 * des Konstruktors der Binaerbaum und hat pContent als Inhaltsobjekt und
+	 * zwei leere Teilbaeume. Falls der Parameter null ist, wird ein leerer
+	 * Binaerbaum erzeugt.
+	 *
+	 * @param pContent
+	 *            das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
+	 */
+	public BinaryTree(ContentType pContent) {
+		if (pContent != null) {
+			this.node = new BTNode<ContentType>(pContent);
+		} else {
+			this.node = null;
+		}
+	}
+
+	/**
+	 * Wenn der Parameter pContent ungleich null ist, wird ein Binaerbaum mit
+	 * pContent als Inhalt und den beiden Teilbaeume pLeftTree und pRightTree
+	 * erzeugt. Sind pLeftTree oder pRightTree gleich null, wird der
+	 * entsprechende Teilbaum als leerer Binaerbaum eingefuegt. So kann es also
+	 * nie passieren, dass linke oder rechte Teilbaeume null sind. Wenn der
+	 * Parameter pContent gleich null ist, wird ein leerer Binaerbaum erzeugt.
+	 *
+	 * @param pContent
+	 *            das Inhaltsobjekt des Wurzelknotens vom Typ ContentType
+	 * @param pLeftTree
+	 *            der linke Teilbaum vom Typ BinaryTree<ContentType>
+	 * @param pRightTree
+	 *            der rechte Teilbaum vom Typ BinaryTree<ContentType>
+	 */
+	public BinaryTree(ContentType pContent, BinaryTree<ContentType> pLeftTree, BinaryTree<ContentType> pRightTree) {
+		if (pContent != null) {
+			this.node = new BTNode<ContentType>(pContent);
+			if (pLeftTree != null) {
+				this.node.left = pLeftTree;
+			} else {
+				this.node.left = new BinaryTree<ContentType>();
+			}
+			if (pRightTree != null) {
+				this.node.right = pRightTree;
+			} else {
+				this.node.right = new BinaryTree<ContentType>();
+			}
+		} else {
+		  // Da der Inhalt null ist, wird ein leerer BinarySearchTree erzeugt.
+			this.node = null;
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert den Wahrheitswert true, wenn der Binaerbaum leer
+	 * ist, sonst liefert sie den Wert false.
+	 *
+	 * @return true, wenn der Binaerbaum leer ist, sonst false
+	 */
+	public boolean isEmpty() {
+		return this.node == null;
+	}
+
+	/**
+	 * Wenn pContent null ist, geschieht nichts. <br />
+	 * Ansonsten: Wenn der Binaerbaum leer ist, wird der Parameter pContent als
+	 * Inhaltsobjekt sowie ein leerer linker und rechter Teilbaum eingefuegt.
+	 * Ist der Binaerbaum nicht leer, wird das Inhaltsobjekt durch pContent
+	 * ersetzt. Die Teilbaeume werden nicht geaendert.
+	 *
+	 * @param pContent
+	 *            neues Inhaltsobjekt vom Typ ContentType
+	 */
+	public void setContent(ContentType pContent) {
+		if (pContent != null) {
+			if (this.isEmpty()) {
+				node = new BTNode<ContentType>(pContent);
+				this.node.left = new BinaryTree<ContentType>();
+				this.node.right = new BinaryTree<ContentType>();
+			}
+			this.node.content = pContent;
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert das Inhaltsobjekt des Binaerbaums. Wenn der
+	 * Binaerbaum leer ist, wird null zurueckgegeben.
+	 *
+	 * @return das Inhaltsobjekt der Wurzel vom Typ ContentType bzw. null, wenn
+	 *         der Binaerbaum leer ist
+	 */
+	public ContentType getContent() {
+		if (this.isEmpty()) {
+			return null;
+		} else {
+			return this.node.content;
+		}
+	}
+
+	/**
+	 * Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer
+	 * ist, wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
+	 * uebergebenen BinaryTree als linken Teilbaum.
+	 *
+	 * @param pTree
+	 *            neuer linker Teilbaum vom Typ BinaryTree<ContentType>
+	 */
+	public void setLeftTree(BinaryTree<ContentType> pTree) {
+		if (!this.isEmpty() && pTree != null) {
+			this.node.left = pTree;
+		}
+	}
+
+	/**
+	 * Falls der Parameter null ist, geschieht nichts. Wenn der Binaerbaum leer
+	 * ist, wird pTree nicht angehaengt. Andernfalls erhaelt der Binaerbaum den
+	 * uebergebenen BinaryTree als rechten Teilbaum.
+	 *
+	 * @param pTree
+	 *            neuer linker Teilbaum vom Typ BinaryTree<ContentType>
+	 */
+	public void setRightTree(BinaryTree<ContentType> pTree) {
+		if (!this.isEmpty() && pTree != null) {
+			this.node.right = pTree;
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert den linken Teilbaum des Binaerbaumes. Wenn der
+	 * Binaerbaum leer ist, wird null zurueckgegeben.
+	 *
+	 * @return linker Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn
+	 * der aktuelle Binaerbaum leer ist
+	 */
+	public BinaryTree<ContentType> getLeftTree() {
+		if (!this.isEmpty()) {
+			return this.node.left;
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * Diese Anfrage liefert den rechten Teilbaum des Binaerbaumes. Wenn der
+	 * Binaerbaum (this) leer ist, wird null zurueckgegeben.
+	 *
+	 * @return rechter Teilbaum vom Typ BinaryTree<ContentType> oder null, wenn
+	 * der aktuelle Binaerbaum (this) leer ist
+	 */
+	public BinaryTree<ContentType> getRightTree() {
+		if (!this.isEmpty()) {
+			return this.node.right;
+		} else {
+			return null;
+		}
+	}
+
+}

src/test/java/schule/ngb/zm/util/abi/Client.java

@@ -0,0 +1,163 @@
+package schule.ngb.zm.util.abi;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Client
+ * </p>
+ * <p>
+ * Objekte von Unterklassen der abstrakten Klasse Client ermoeglichen
+ * Netzwerkverbindungen zu einem Server mittels TCP/IP-Protokoll. Nach
+ * Verbindungsaufbau koennen Zeichenketten (Strings) zum Server gesendet und von
+ * diesem empfangen werden, wobei der Nachrichtenempfang nebenlaeufig geschieht.
+ * Zur Vereinfachung finden Nachrichtenversand und -empfang zeilenweise statt,
+ * d. h., beim Senden einer Zeichenkette wird ein Zeilentrenner ergaenzt und beim
+ * Empfang wird dieser entfernt. Jede empfangene Nachricht wird einer
+ * Ereignisbehandlungsmethode uebergeben, die in Unterklassen implementiert werden
+ * muss. Es findet nur eine rudimentaere Fehlerbehandlung statt, so dass z.B.
+ * Verbindungsabbrueche nicht zu einem Programmabbruch fuehren. Eine einmal
+ * unterbrochene oder getrennte Verbindung kann nicht reaktiviert werden.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version 30.08.2016
+ */
+
+public abstract class Client
+{
+    private MessageHandler messageHandler;
+
+    private class MessageHandler extends Thread
+    {
+        private SocketWrapper socketWrapper;
+        private boolean active;
+
+        private class SocketWrapper
+        {
+            private Socket socket;
+            private BufferedReader fromServer;
+            private PrintWriter toServer;
+
+            public SocketWrapper(String pServerIP, int pServerPort)
+            {
+                try
+                {
+                	socket = new Socket(pServerIP, pServerPort);
+                    toServer = new PrintWriter(socket.getOutputStream(), true);
+                    fromServer = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+                }
+                catch (IOException e)
+                {
+                    socket = null;
+                    toServer = null;
+                    fromServer = null;
+                }
+            }
+
+            public String receive()
+            {
+                if(fromServer != null)
+                    try
+                    {
+                        return fromServer.readLine();
+                    }
+                    catch (IOException e)
+                    {
+                    }
+                return(null);
+            }
+
+            public void send(String pMessage)
+            {
+                if(toServer != null)
+                {
+                    toServer.println(pMessage);
+                }
+            }
+
+            public void close()
+            {
+                if(socket != null)
+                    try
+                    {
+                        socket.close();
+                    }
+                    catch (IOException e)
+                    {
+                        /*
+                         * Falls eine Verbindung getrennt werden soll, deren Endpunkt
+                         * nicht mehr existiert bzw. ihrerseits bereits beendet worden ist,
+                         * geschieht nichts.
+                         */
+                    }
+            }
+        }
+
+        private MessageHandler(String pServerIP, int pServerPort)
+        {
+            socketWrapper = new SocketWrapper(pServerIP, pServerPort);
+            start();
+            if(socketWrapper.socket != null)
+            	active = true;
+        }
+
+        public void run()
+        {
+            String message = null;
+            while (active)
+            {
+                message = socketWrapper.receive();
+                if (message != null)
+                    processMessage(message);
+                else
+                    close();
+            }
+        }
+
+        private void send(String pMessage)
+        {
+            if(active)
+                socketWrapper.send(pMessage);
+        }
+
+        private void close()
+        {
+            if(active)
+            {
+                active = false;
+                socketWrapper.close();
+            }
+        }
+    }
+
+    public Client(String pServerIP, int pServerPort)
+    {
+        messageHandler = new MessageHandler(pServerIP, pServerPort);
+    }
+
+    public boolean isConnected()
+    {
+   		return(messageHandler.active);
+    }
+
+    public void send(String pMessage)
+    {
+        messageHandler.send(pMessage);
+    }
+
+    public void close()
+    {
+        messageHandler.close();
+    }
+
+    public abstract void processMessage(String pMessage);
+
+}

src/test/java/schule/ngb/zm/util/abi/ComparableContent.java

@@ -0,0 +1,62 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generisches Interface (Schnittstelle) ComparableContent<ContentType>
+ * </p>
+ * <p>
+ * <p>Das generische Interface ComparableContent<ContentType> legt die Methoden
+ * fest, ueber die Objekte verfuegen muessen, die in einen binaeren Suchbaum
+ * (BinarySearchTree) eingefuegt werden sollen. Die Ordnungsrelation wird in
+ * Klassen, die ComparableContent implementieren durch Ueberschreiben der drei
+ * implizit abstrakten Methoden isGreater, isEqual und isLess festgelegt.
+ * </p>
+ * </p>
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_02 2014-03-01
+ */
+public interface ComparableContent<ContentType> {
+
+  /**
+   * Wenn festgestellt wird, dass das Objekt, von dem die Methode aufgerufen
+   * wird, bzgl. der gewuenschten Ordnungsrelation groesser als das Objekt
+   * pContent ist, wird true geliefert. Sonst wird false geliefert.
+   *
+   * @param pContent
+   *          das mit dem aufrufenden Objekt zu vergleichende Objekt vom
+   *          Typ ContentType
+   * @return true, wenn das aufrufende Objekt groesser ist als das Objekt
+   *         pContent, sonst false
+   */
+  public boolean isGreater(ContentType pContent);
+
+  /**
+   * Wenn festgestellt wird, dass das Objekt, von dem die Methode aufgerufen
+   * wird, bzgl. der gewuenschten Ordnungsrelation gleich gross wie das Objekt
+   * pContent ist, wird true geliefert. Sonst wird false geliefert.
+   *
+   * @param pContent
+   *          das mit dem aufrufenden Objekt zu vergleichende Objekt vom
+   *          Typ ContentType
+   * @return true, wenn das aufrufende Objekt gleich gross ist wie das Objekt
+   *         pContent, sonst false
+   */
+  public boolean isEqual(ContentType pContent);
+
+  /**
+   * Wenn festgestellt wird, dass das Objekt, von dem die Methode aufgerufen
+   * wird, bzgl. der gewuenschten Ordnungsrelation kleiner als das Objekt
+   * pContent ist, wird true geliefert. Sonst wird false geliefert.
+   *
+   * @param pContent
+   *          das mit dem aufrufenden Objekt zu vergleichende Objekt vom
+   *          Typ ContentType
+   * @return true, wenn das aufrufende Objekt kleiner ist als das Objekt
+   *         pContent, sonst false
+   */
+  public boolean isLess(ContentType pContent);
+
+}

src/test/java/schule/ngb/zm/util/abi/Connection.java

@@ -0,0 +1,90 @@
+package schule.ngb.zm.util.abi; /**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Connection
+ * </p>
+ * <p>
+ * Objekte der Klasse Connection ermoeglichen eine Netzwerkverbindung zu einem
+ * Server mittels TCP/IP-Protokoll. Nach Verbindungsaufbau koennen Zeichenketten
+ * (Strings) zum Server gesendet und von diesem empfangen werden. Zur
+ * Vereinfachung geschieht dies zeilenweise, d. h., beim Senden einer
+ * Zeichenkette wird ein Zeilentrenner ergaenzt und beim Empfang wird dieser
+ * entfernt. Es findet nur eine rudimentaere Fehlerbehandlung statt, so dass z.B.
+ * der Zugriff auf unterbrochene oder bereits getrennte Verbindungen nicht zu
+ * einem Programmabbruch fuehrt. Eine einmal getrennte Verbindung kann nicht
+ * reaktiviert werden.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version 30.08.2016
+ */
+
+import java.net.*;
+import java.io.*;
+
+public class Connection
+{
+    private Socket socket;
+    private BufferedReader fromServer;
+    private PrintWriter toServer;
+
+    public Connection(String pServerIP, int pServerPort)
+    {
+        try
+        {
+            socket = new Socket(pServerIP, pServerPort);
+            toServer = new PrintWriter(socket.getOutputStream(), true);
+            fromServer = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+        }
+        catch (Exception e)
+        {
+            //Erstelle eine nicht-verbundene Instanz von Socket, wenn die avisierte
+            //Verbindung nicht hergestellt werden kann
+            socket = null;
+            toServer = null;
+            fromServer = null;
+        }
+    }
+
+    public String receive()
+    {
+        if(fromServer != null)
+            try
+            {
+                return fromServer.readLine();
+            }
+            catch (IOException e)
+            {
+            }
+        return(null);
+    }
+
+    public void send(String pMessage)
+    {
+        if(toServer != null)
+        {
+            toServer.println(pMessage);
+         }
+    }
+
+    public void close()
+    {
+
+        if(socket != null && !socket.isClosed())
+            try
+            {
+                socket.close();
+            }
+            catch (IOException e)
+            {
+                /*
+                 * Falls eine Verbindung geschlossen werden soll, deren Endpunkt nicht
+                 * mehr existiert bzw. seinerseits bereits geschlossen worden ist oder
+                 * die nicht korrekt instanziiert werden konnte (socket == null), geschieht
+                 * nichts.
+                 */
+            }
+    }
+}

src/test/java/schule/ngb/zm/util/abi/DatabaseConnector.java

@@ -0,0 +1,151 @@
+package schule.ngb.zm.util.abi;
+
+import java.sql.*;
+import java.sql.Connection;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse DatabaseConnector
+ * </p>
+ * <p>
+ * Ein Objekt der Klasse DatabaseConnector ermoeglicht die Abfrage und Manipulation
+ * einer SQLite-Datenbank.
+ * Beim Erzeugen des Objekts wird eine Datenbankverbindung aufgebaut, so dass
+ * anschließend SQL-Anweisungen an diese Datenbank gerichtet werden koennen.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version 2016-01-24
+ */
+public class DatabaseConnector{
+  private Connection connection;
+  private QueryResult currentQueryResult = null;
+  private String message = null;
+
+  /**
+   * Ein Objekt vom Typ DatabaseConnector wird erstellt, und eine Verbindung zur Datenbank
+   * wird aufgebaut. Mit den Parametern pIP und pPort werden die IP-Adresse und die
+   * Port-Nummer uebergeben, unter denen die Datenbank mit Namen pDatabase zu erreichen ist.
+   * Mit den Parametern pUsername und pPassword werden Benutzername und Passwort fuer die
+   * Datenbank uebergeben.
+   */
+  public DatabaseConnector(String pIP, int pPort, String pDatabase, String pUsername, String pPassword){
+    //Eine Impementierung dieser Schnittstelle fuer SQLite ignoriert pID und pPort, da die Datenbank immer lokal ist.
+    //Auch pUsername und pPassword werden nicht verwendet, da SQLite sie nicht unterstuetzt.
+    try {
+      //Laden der Treiberklasse
+      Class.forName("org.sqlite.JDBC");
+
+      //Verbindung herstellen
+      connection = DriverManager.getConnection("jdbc:sqlite:"+pDatabase);
+
+    } catch (Exception e) {
+      message = e.getMessage();
+    }
+  }
+
+  /**
+   * Der Auftrag schickt den im Parameter pSQLStatement enthaltenen SQL-Befehl an die
+   * Datenbank ab.
+   * Handelt es sich bei pSQLStatement um einen SQL-Befehl, der eine Ergebnismenge
+   * liefert, so kann dieses Ergebnis anschließend mit der Methode getCurrentQueryResult
+   * abgerufen werden.
+   */
+  public void executeStatement(String pSQLStatement){
+    //Altes Ergebnis loeschen
+    currentQueryResult = null;
+    message = null;
+
+    try {
+      //Neues Statement erstellen
+      Statement statement = connection.createStatement();
+
+      //SQL Anweisung an die DB schicken.
+      if (statement.execute(pSQLStatement)) { //Fall 1: Es gibt ein Ergebnis
+
+        //Resultset auslesen
+        ResultSet resultset = statement.getResultSet();
+
+        //Spaltenanzahl ermitteln
+        int columnCount = resultset.getMetaData().getColumnCount();
+
+        //Spaltennamen und Spaltentypen in Felder uebertragen
+        String[] resultColumnNames = new String[columnCount];
+        String[] resultColumnTypes = new String[columnCount];
+        for (int i = 0; i < columnCount; i++){
+          resultColumnNames[i] = resultset.getMetaData().getColumnLabel(i+1);
+          resultColumnTypes[i] = resultset.getMetaData().getColumnTypeName(i+1);
+        }
+
+        //Queue fuer die Zeilen der Ergebnistabelle erstellen
+        Queue<String[]> rows = new Queue<String[]>();
+
+        //Daten in Queue uebertragen und Zeilen zaehlen
+        int rowCount = 0;
+        while (resultset.next()){
+          String[] resultrow =  new String[columnCount];
+          for (int s = 0; s < columnCount; s++){
+            resultrow[s] = resultset.getString(s+1);
+          }
+          rows.enqueue(resultrow);
+          rowCount = rowCount + 1;
+        }
+
+        //Ergebnisfeld erstellen und Zeilen aus Queue uebertragen
+        String[][] resultData = new String[rowCount][columnCount];
+        int j = 0;
+        while (!rows.isEmpty()){
+          resultData[j] = rows.front();
+          rows.dequeue();
+          j = j + 1;
+        }
+
+        //Statement schließen und Ergebnisobjekt erstellen
+        statement.close();
+        currentQueryResult =  new QueryResult(resultData, resultColumnNames, resultColumnTypes);
+
+      } else { //Fall 2: Es gibt kein Ergebnis.
+        //Statement ohne Ergebnisobjekt schliessen
+        statement.close();
+      }
+
+    } catch (Exception e) {
+      //Fehlermeldung speichern
+      message = e.getMessage();
+    }
+  }
+
+  /**
+   * Die Anfrage liefert das Ergebnis des letzten mit der Methode executeStatement an
+   * die Datenbank geschickten SQL-Befehls als Ob-jekt vom Typ QueryResult zurueck.
+   * Wurde bisher kein SQL-Befehl abgeschickt oder ergab der letzte Aufruf von
+   * executeStatement keine Ergebnismenge (z.B. bei einem INSERT-Befehl oder einem
+   * Syntaxfehler), so wird null geliefert.
+   */
+  public QueryResult getCurrentQueryResult(){
+    return currentQueryResult;
+  }
+
+  /**
+   * Die Anfrage liefert null oder eine Fehlermeldung, die sich jeweils auf die letzte zuvor ausgefuehrte
+   * Datenbankoperation bezieht.
+   */
+  public String getErrorMessage(){
+    return message;
+  }
+
+  /**
+   * Die Datenbankverbindung wird geschlossen.
+   */
+  public void close(){
+    try{
+      connection.close();
+    } catch (Exception e) {
+      message = e.getMessage();
+    }
+  }
+
+}

src/test/java/schule/ngb/zm/util/abi/Edge.java

@@ -0,0 +1,77 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Edge
+ * </p>
+ * <p>
+ * Die Klasse Edge stellt eine einzelne, ungerichtete Kante eines Graphen dar.
+ * Beim Erstellen werden die beiden durch sie zu verbindenden Knotenobjekte und eine
+ * Gewichtung als double uebergeben. Beide Knotenobjekte koennen abgefragt werden.
+ * Des Weiteren koennen die Gewichtung und eine Markierung gesetzt und abgefragt werden.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Oktober 2015
+ */
+public class Edge{
+  private Vertex[] vertices;
+  private double weight;
+  private boolean mark;
+
+  /**
+  * Ein neues Objekt vom Typ Edge wird erstellt. Die von diesem Objekt
+  * repraesentierte Kante verbindet die Knoten pVertex und pAnotherVertex mit der
+  * Gewichtung pWeight. Ihre Markierung hat den Wert false.
+  */
+  public Edge( Vertex pVertex, Vertex pAnotherVertex, double pWeight){
+    vertices = new Vertex[2];
+    vertices[0] = pVertex;
+    vertices[1] = pAnotherVertex;
+    weight = pWeight;
+    mark = false;
+  }
+
+  /**
+  * Die Anfrage gibt die beiden Knoten, die durch die Kante verbunden werden, als neues Feld vom Typ Vertex zurueck. Das Feld hat
+  * genau zwei Eintraege mit den Indexwerten 0 und 1.
+  */
+  public Vertex[] getVertices(){
+    Vertex[] result = new Vertex[2];
+    result[0] = vertices[0];
+    result[1] = vertices[1];
+    return result;
+  }
+
+  /**
+  * Der Auftrag setzt das Gewicht der Kante auf pWeight.
+  */
+  public void setWeight(double pWeight){
+    weight = pWeight;
+  }
+
+  /**
+  * Die Anfrage liefert das Gewicht der Kante als double.
+  */
+  public double getWeight(){
+    return weight;
+  }
+
+  /**
+  * Der Auftrag setzt die Markierung der Kante auf den Wert pMark.
+  */
+  public void setMark(boolean pMark){
+    mark = pMark;
+  }
+
+  /**
+  * Die Anfrage liefert true, wenn die Markierung der Kante den Wert true hat, ansonsten false.
+  */
+  public boolean isMarked(){
+    return mark;
+  }
+
+}

src/test/java/schule/ngb/zm/util/abi/Graph.java

@@ -0,0 +1,314 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Graph
+ * </p>
+ * <p>
+ * Die Klasse Graph stellt einen ungerichteten, kantengewichteten Graphen dar. Es koennen
+ * Knoten- und Kantenobjekte hinzugefuegt und entfernt, flache Kopien der Knoten- und Kantenlisten
+ * des Graphen angefragt und Markierungen von Knoten und Kanten gesetzt und ueberprueft werden.
+ * Des Weiteren kann eine Liste der Nachbarn eines bestimmten Knoten, eine Liste der inzidenten
+ * Kanten eines bestimmten Knoten und die Kante von einem bestimmten Knoten zu einem
+ * anderen bestimmten Knoten angefragt werden. Abgesehen davon kann abgefragt werden, welches
+ * Knotenobjekt zu einer bestimmten ID gehoert und ob der Graph leer ist.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Oktober 2015
+ */
+public class Graph{
+  private List<Vertex> vertices;
+  private List<Edge> edges;
+
+  /**
+   * Ein Objekt vom Typ Graph wird erstellt. Der von diesem Objekt
+   * repraesentierte Graph ist leer.
+   */
+  public Graph(){
+    //Leere Listen fuer Knoten und Kanten erstellen.
+    vertices = new List<Vertex>();
+    edges = new List<Edge>();
+  }
+
+  /**
+   * Die Anfrage liefert eine neue Liste aller Knotenobjekte vom Typ List<Vertex>.
+   */
+  public List<Vertex> getVertices(){
+    //Eine neue Liste mit allen Vertex-Objekten erstellen.
+    List<Vertex> result = new List<Vertex>();
+    vertices.toFirst();
+    while (vertices.hasAccess()){
+      result.append(vertices.getContent());
+      vertices.next();
+    }
+    //Aktuelles Element zum Anfang bewegen.
+    result.toFirst();
+
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert eine neue Liste aller Kantenobjekte vom Typ List<Edge>.
+   */
+  public List<Edge> getEdges(){
+    //Eine neue Liste mit allen Edge-Objekten erstellen.
+    List<Edge> result = new List<Edge>();
+    edges.toFirst();
+    while (edges.hasAccess()){
+      result.append(edges.getContent());
+      edges.next();
+    }
+    //Aktuelles Element zum Anfang bewegen.
+    result.toFirst();
+
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert das Knotenobjekt mit pID als ID. Ist ein solchen Knotenobjekt nicht im Graphen enthalten,
+   * wird null zurueckgeliefert.
+   */
+  public Vertex getVertex( String pID){
+    //Vertex-Objekt mit pID als ID suchen.
+    Vertex result = null;
+    vertices.toFirst();
+    while (vertices.hasAccess() && result == null){
+      if (vertices.getContent().getID().equals(pID)){
+        result = vertices.getContent();
+      }
+      vertices.next();
+    }
+
+    //Objekt zurueckliefern.
+    return result;
+  }
+
+  /**
+   * Der Auftrag fuegt den Knoten pVertex in den Graphen ein, sofern es noch keinen
+   * Knoten mit demselben ID-Eintrag wie pVertex im Graphen gibt und pVertex eine ID ungleich null hat.
+   * Ansonsten passiert nichts.
+   */
+  public void addVertex( Vertex pVertex){
+    //Pruefen, ob der Vertex existiert und eine ID hat.
+    if (pVertex != null && pVertex.getID() != null) {
+      //Pruefen, ob nicht schon ein Vertex mit gleicher ID enthalten ist.
+      boolean freeID = true;
+      vertices.toFirst();
+      while (vertices.hasAccess() && freeID){
+        if (vertices.getContent().getID().equals(pVertex.getID())){
+          freeID = false;
+        }
+        vertices.next();
+      }
+
+      //Wenn die ID noch frei ist, den Vertex einfuegen, sonst nichts tun.
+      if (freeID) {
+        vertices.append(pVertex);
+      }
+    }
+  }
+
+  /**
+   * Der Auftrag fuegt die Kante pEdge in den Graphen ein, sofern beide durch die Kante verbundenen Knoten
+   * im Graphen enthalten sind, nicht identisch sind und noch keine Kante zwischen den Knoten existiert. Ansonsten passiert nichts.
+   */
+  public void addEdge(Edge pEdge){
+    //Pruefen, ob pEdge exisitert.
+    if (pEdge != null){
+      Vertex[] vertexPair = pEdge.getVertices();
+
+      //Einfuegekriterien pruefen.
+      if (vertexPair[0] != null && vertexPair[1] != null &&
+      this.getVertex(vertexPair[0].getID()) == vertexPair[0] &&
+      this.getVertex(vertexPair[1].getID()) == vertexPair[1] &&
+      this.getEdge(vertexPair[0], vertexPair[1]) == null &&
+      vertexPair[0] != vertexPair[1]){
+        //Kante einfuegen.
+        edges.append(pEdge);
+      }
+    }
+  }
+
+  /**
+   * Der Auftrag entfernt den Knoten pVertex aus dem Graphen und loescht alle Kanten, die mit ihm inzident sind.
+   * Ist der Knoten pVertex nicht im Graphen enthalten, passiert nichts.
+   */
+  public void removeVertex( Vertex pVertex){
+    //Inzidente Kanten entfernen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+      Vertex[] akt = edges.getContent().getVertices();
+      if (akt[0] == pVertex || akt[1] == pVertex){
+        edges.remove();
+      } else {
+        edges.next();
+      }
+    }
+
+    //Knoten entfernen
+    vertices.toFirst();
+    while (vertices.hasAccess() && vertices.getContent()!= pVertex){
+      vertices.next();
+    }
+    if (vertices.hasAccess()){
+      vertices.remove();
+    }
+  }
+
+  /**
+   * Der Auftrag entfernt die Kante pEdge aus dem Graphen. Ist die Kante pEdge nicht
+   * im Graphen enthalten, passiert nichts.
+   */
+  public void removeEdge(Edge pEdge){
+    //Kante aus Kantenliste des Graphen entfernen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+      if (edges.getContent() == pEdge){
+        edges.remove();
+      } else {
+        edges.next();
+      }
+    }
+  }
+
+  /**
+   * Der Auftrag setzt die Markierungen aller Knoten des Graphen auf pMark.
+   */
+  public void setAllVertexMarks(boolean pMark){
+    vertices.toFirst();
+    while (vertices.hasAccess()){
+      vertices.getContent().setMark(pMark);
+      vertices.next();
+    }
+  }
+
+  /**
+   * Der Auftrag setzt die Markierungen aller Kanten des Graphen auf pMark.
+   */
+  public void setAllEdgeMarks(boolean pMark){
+    edges.toFirst();
+    while (edges.hasAccess()){
+      edges.getContent().setMark(pMark);
+      edges.next();
+    }
+  }
+
+  /**
+   * Die Anfrage liefert true, wenn alle Knoten des Graphen mit true markiert sind, ansonsten false.
+   */
+  public boolean allVerticesMarked(){
+    boolean result = true;
+    vertices.toFirst();
+    while (vertices.hasAccess()){
+      if (!vertices.getContent().isMarked()){
+        result = false;
+      }
+      vertices.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert true, wenn alle Kanten des Graphen mit true markiert sind, ansonsten false.
+   */
+  public boolean allEdgesMarked(){
+    boolean result = true;
+    edges.toFirst();
+    while (edges.hasAccess()){
+      if (!edges.getContent().isMarked()){
+        result = false;
+      }
+      edges.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert alle Nachbarn des Knotens pVertex als neue Liste vom Typ List<Vertex>. Hat der Knoten
+   * pVertex keine Nachbarn in diesem Graphen oder ist gar nicht in diesem Graphen enthalten, so
+   * wird eine leere Liste zurueckgeliefert.
+   */
+  public List<Vertex> getNeighbours( Vertex pVertex){
+    List<Vertex> result = new List<Vertex>();
+
+    //Alle Kanten durchlaufen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+
+      //Wenn ein Knoten der Kante pVertex ist, den anderen als Nachbarn in die Ergebnisliste einfuegen.
+      Vertex[] vertexPair = edges.getContent().getVertices();
+      if (vertexPair[0] == pVertex) {
+        result.append(vertexPair[1]);
+      } else {
+        if (vertexPair[1] == pVertex){
+          result.append(vertexPair[0]);
+        }
+      }
+      edges.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert eine neue Liste alle inzidenten Kanten zum Knoten pVertex. Hat der Knoten
+   * pVertex keine inzidenten Kanten in diesem Graphen oder ist gar nicht in diesem Graphen enthalten, so
+   * wird eine leere Liste zurueckgeliefert.
+   */
+  public List<Edge> getEdges( Vertex pVertex){
+    List<Edge> result = new List<Edge>();
+
+    //Alle Kanten durchlaufen.
+    edges.toFirst();
+    while (edges.hasAccess()){
+
+      //Wenn ein Knoten der Kante pVertex ist, dann Kante als inzidente Kante in die Ergebnisliste einfuegen.
+      Vertex[] vertexPair = edges.getContent().getVertices();
+      if (vertexPair[0] == pVertex) {
+        result.append(edges.getContent());
+      } else{
+        if (vertexPair[1] == pVertex){
+          result.append(edges.getContent());
+        }
+      }
+      edges.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert die Kante, welche die Knoten pVertex und pAnotherVertex verbindet,
+   * als Objekt vom Typ Edge. Ist der Knoten pVertex oder der Knoten pAnotherVertex nicht
+   * im Graphen enthalten oder gibt es keine Kante, die beide Knoten verbindet, so wird null
+   * zurueckgeliefert.
+   */
+  public Edge getEdge( Vertex pVertex, Vertex pAnotherVertex){
+    Edge result = null;
+
+    //Kanten durchsuchen, solange keine passende gefunden wurde.
+    edges.toFirst();
+    while (edges.hasAccess() && result == null){
+
+      //Pruefen, ob die Kante pVertex und pAnotherVertex verbindet.
+      Vertex[] vertexPair = edges.getContent().getVertices();
+      if ((vertexPair[0] == pVertex && vertexPair[1] == pAnotherVertex) ||
+      (vertexPair[0] == pAnotherVertex && vertexPair[1] == pVertex)) {
+        //Kante als Ergebnis merken.
+        result = edges.getContent();
+      }
+      edges.next();
+    }
+    return result;
+  }
+
+  /**
+   * Die Anfrage liefert true, wenn der Graph keine Knoten enthaelt, ansonsten false.
+   */
+  public boolean isEmpty(){
+    return vertices.isEmpty();
+  }
+
+}

src/test/java/schule/ngb/zm/util/abi/List.java

@@ -0,0 +1,347 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse List<ContentType>
+ * </p>
+ * <p>
+ * Objekt der generischen Klasse List verwalten beliebig viele linear
+ * angeordnete Objekte vom Typ ContentType. Auf hoechstens ein Listenobjekt,
+ * aktuellesObjekt genannt, kann jeweils zugegriffen werden.<br />
+ * Wenn eine Liste leer ist, vollstaendig durchlaufen wurde oder das aktuelle
+ * Objekt am Ende der Liste geloescht wurde, gibt es kein aktuelles Objekt.<br />
+ * Das erste oder das letzte Objekt einer Liste koennen durch einen Auftrag zum
+ * aktuellen Objekt gemacht werden. Ausserdem kann das dem aktuellen Objekt
+ * folgende Listenobjekt zum neuen aktuellen Objekt werden. <br />
+ * Das aktuelle Objekt kann gelesen, veraendert oder geloescht werden. Ausserdem
+ * kann vor dem aktuellen Objekt ein Listenobjekt eingefuegt werden.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_06 2015-10-25
+ */
+public class List<ContentType> {
+
+  /* --------- Anfang der privaten inneren Klasse -------------- */
+
+  private class ListNode {
+
+    private ContentType contentObject;
+    private ListNode next;
+
+    /**
+     * Ein neues Objekt wird erschaffen. Der Verweis ist leer.
+     *
+     * @param pContent das Inhaltsobjekt vom Typ ContentType
+     */
+    private ListNode(ContentType pContent) {
+      contentObject = pContent;
+      next = null;
+    }
+
+    /**
+     * Der Inhalt des Knotens wird zurueckgeliefert.
+     *
+     * @return das Inhaltsobjekt des Knotens
+     */
+    public ContentType getContentObject() {
+      return contentObject;
+    }
+
+    /**
+     * Der Inhalt dieses Kontens wird gesetzt.
+     *
+     * @param pContent das Inhaltsobjekt vom Typ ContentType
+     */
+    public void setContentObject(ContentType pContent) {
+      contentObject = pContent;
+    }
+
+    /**
+     * Der Nachfolgeknoten wird zurueckgeliefert.
+     *
+     * @return das Objekt, auf das der aktuelle Verweis zeigt
+     */
+    public ListNode getNextNode() {
+      return this.next;
+    }
+
+    /**
+     * Der Verweis wird auf das Objekt, das als Parameter uebergeben
+     * wird, gesetzt.
+     *
+     * @param pNext der Nachfolger des Knotens
+     */
+    public void setNextNode(ListNode pNext) {
+      this.next = pNext;
+    }
+
+  }
+
+  /* ----------- Ende der privaten inneren Klasse -------------- */
+
+  // erstes Element der Liste
+  ListNode first;
+
+  // letztes Element der Liste
+  ListNode last;
+
+  // aktuelles Element der Liste
+  ListNode current;
+
+  /**
+   * Eine leere Liste wird erzeugt.
+   */
+  public List() {
+    first = null;
+    last = null;
+    current = null;
+  }
+
+  /**
+   * Die Anfrage liefert den Wert true, wenn die Liste keine Objekte enthaelt,
+   * sonst liefert sie den Wert false.
+   *
+   * @return true, wenn die Liste leer ist, sonst false
+   */
+  public boolean isEmpty() {
+    // Die Liste ist leer, wenn es kein erstes Element gibt.
+    return first == null;
+  }
+
+  /**
+   * Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt gibt,
+   * sonst liefert sie den Wert false.
+   *
+   * @return true, falls Zugriff moeglich, sonst false
+   */
+  public boolean hasAccess() {
+    // Es gibt keinen Zugriff, wenn current auf kein Element verweist.
+    return current != null;
+  }
+
+  /**
+   * Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses
+   * nicht das letzte Objekt der Liste ist, wird das dem aktuellen Objekt in
+   * der Liste folgende Objekt zum aktuellen Objekt, andernfalls gibt es nach
+   * Ausfuehrung des Auftrags kein aktuelles Objekt, d.h. hasAccess() liefert
+   * den Wert false.
+   */
+  public void next() {
+    if (this.hasAccess()) {
+      current = current.getNextNode();
+    }
+  }
+
+  /**
+   * Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktuelles
+   * Objekt. Ist die Liste leer, geschieht nichts.
+   */
+  public void toFirst() {
+    if (!isEmpty()) {
+      current = first;
+    }
+  }
+
+  /**
+   * Falls die Liste nicht leer ist, wird das letzte Objekt der Liste
+   * aktuelles Objekt. Ist die Liste leer, geschieht nichts.
+   */
+  public void toLast() {
+    if (!isEmpty()) {
+      current = last;
+    }
+  }
+
+  /**
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
+   * aktuelle Objekt zurueckgegeben, andernfalls (hasAccess() == false) gibt
+   * die Anfrage den Wert null zurueck.
+   *
+   * @return das aktuelle Objekt (vom Typ ContentType) oder null, wenn es
+   *         kein aktuelles Objekt gibt
+   */
+  public ContentType getContent() {
+    if (this.hasAccess()) {
+      return current.getContentObject();
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true) und pContent
+   * ungleich null ist, wird das aktuelle Objekt durch pContent ersetzt. Sonst
+   * geschieht nichts.
+   *
+   * @param pContent
+   *            das zu schreibende Objekt vom Typ ContentType
+   */
+  public void setContent(ContentType pContent) {
+    // Nichts tun, wenn es keinen Inhalt oder kein aktuelles Element gibt.
+    if (pContent != null && this.hasAccess()) {
+      current.setContentObject(pContent);
+    }
+  }
+
+  /**
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein neues
+   * Objekt vor dem aktuellen Objekt in die Liste eingefuegt. Das aktuelle
+   * Objekt bleibt unveraendert. <br />
+   * Wenn die Liste leer ist, wird pContent in die Liste eingefuegt und es
+   * gibt weiterhin kein aktuelles Objekt (hasAccess() == false). <br />
+   * Falls es kein aktuelles Objekt gibt (hasAccess() == false) und die Liste
+   * nicht leer ist oder pContent gleich null ist, geschieht nichts.
+   *
+   * @param pContent
+   *            das einzufuegende Objekt vom Typ ContentType
+   */
+  public void insert(ContentType pContent) {
+    if (pContent != null) { // Nichts tun, wenn es keinen Inhalt gibt.
+      if (this.hasAccess()) { // Fall: Es gibt ein aktuelles Element.
+
+        // Neuen Knoten erstellen.
+        ListNode newNode = new ListNode(pContent);
+
+        if (current != first) { // Fall: Nicht an erster Stelle einfuegen.
+          ListNode previous = this.getPrevious(current);
+          newNode.setNextNode(previous.getNextNode());
+          previous.setNextNode(newNode);
+        } else { // Fall: An erster Stelle einfuegen.
+          newNode.setNextNode(first);
+          first = newNode;
+        }
+
+      } else { //Fall: Es gibt kein aktuelles Element.
+
+        if (this.isEmpty()) { // Fall: In leere Liste einfuegen.
+
+          // Neuen Knoten erstellen.
+          ListNode newNode = new ListNode(pContent);
+
+          first = newNode;
+          last = newNode;
+        }
+
+      }
+    }
+  }
+
+  /**
+   * Falls pContent gleich null ist, geschieht nichts.<br />
+   * Ansonsten wird ein neues Objekt pContent am Ende der Liste eingefuegt.
+   * Das aktuelle Objekt bleibt unveraendert. <br />
+   * Wenn die Liste leer ist, wird das Objekt pContent in die Liste eingefuegt
+   * und es gibt weiterhin kein aktuelles Objekt (hasAccess() == false).
+   *
+   * @param pContent
+   *            das anzuhaengende Objekt vom Typ ContentType
+   */
+  public void append(ContentType pContent) {
+    if (pContent != null) { // Nichts tun, wenn es keine Inhalt gibt.
+
+      if (this.isEmpty()) { // Fall: An leere Liste anfuegen.
+        this.insert(pContent);
+      } else { // Fall: An nicht-leere Liste anfuegen.
+
+        // Neuen Knoten erstellen.
+        ListNode newNode = new ListNode(pContent);
+
+        last.setNextNode(newNode);
+        last = newNode; // Letzten Knoten aktualisieren.
+      }
+
+    }
+  }
+
+  /**
+   * Falls es sich bei der Liste und pList um dasselbe Objekt handelt,
+   * pList null oder eine leere Liste ist, geschieht nichts.<br />
+   * Ansonsten wird die Liste pList an die aktuelle Liste angehaengt.
+   * Anschliessend wird pList eine leere Liste. Das aktuelle Objekt bleibt
+   * unveraendert. Insbesondere bleibt hasAccess identisch.
+   *
+   * @param pList
+   *            die am Ende anzuhaengende Liste vom Typ List<ContentType>
+   */
+  public void concat(List<ContentType> pList) {
+    if (pList != this && pList != null && !pList.isEmpty()) { // Nichts tun,
+    // wenn pList und this identisch, pList leer oder nicht existent.
+
+      if (this.isEmpty()) { // Fall: An leere Liste anfuegen.
+        this.first = pList.first;
+        this.last = pList.last;
+      } else { // Fall: An nicht-leere Liste anfuegen.
+        this.last.setNextNode(pList.first);
+        this.last = pList.last;
+      }
+
+      // Liste pList loeschen.
+      pList.first = null;
+      pList.last = null;
+      pList.current = null;
+    }
+  }
+
+  /**
+   * Wenn die Liste leer ist oder es kein aktuelles Objekt gibt (hasAccess()
+   * == false), geschieht nichts.<br />
+   * Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das
+   * aktuelle Objekt geloescht und das Objekt hinter dem geloeschten Objekt
+   * wird zum aktuellen Objekt. <br />
+   * Wird das Objekt, das am Ende der Liste steht, geloescht, gibt es kein
+   * aktuelles Objekt mehr.
+   */
+  public void remove() {
+    // Nichts tun, wenn es kein aktuelle Element gibt oder die Liste leer ist.
+    if (this.hasAccess() && !this.isEmpty()) {
+
+      if (current == first) {
+        first = first.getNextNode();
+      } else {
+        ListNode previous = this.getPrevious(current);
+        if (current == last) {
+          last = previous;
+        }
+        previous.setNextNode(current.getNextNode());
+      }
+
+      ListNode temp = current.getNextNode();
+      current.setContentObject(null);
+      current.setNextNode(null);
+      current = temp;
+
+      //Beim loeschen des letzten Elements last auf null setzen.
+      if (this.isEmpty()) {
+        last = null;
+      }
+    }
+  }
+
+  /**
+   * Liefert den Vorgaengerknoten des Knotens pNode. Ist die Liste leer, pNode
+   * == null, pNode nicht in der Liste oder pNode der erste Knoten der Liste,
+   * wird null zurueckgegeben.
+   *
+   * @param pNode
+   *         der Knoten, dessen Vorgaenger zurueckgegeben werden soll
+   * @return der Vorgaenger des Knotens pNode oder null, falls die Liste leer ist,
+   *         pNode == null ist, pNode nicht in der Liste ist oder pNode der erste Knoten
+   *         der Liste ist
+   */
+  private ListNode getPrevious(ListNode pNode) {
+    if (pNode != null && pNode != first && !this.isEmpty()) {
+      ListNode temp = first;
+      while (temp != null && temp.getNextNode() != pNode) {
+        temp = temp.getNextNode();
+      }
+      return temp;
+    } else {
+      return null;
+    }
+  }
+
+}

src/test/java/schule/ngb/zm/util/abi/QueryResult.java

@@ -0,0 +1,78 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse QueryResult
+ * </p>
+ * <p>
+ * Ein Objekt der Klasse QueryResult stellt die Ergebnistabelle einer Datenbankanfrage mit Hilfe
+ * der Klasse DatabaseConnector dar. Objekte dieser Klasse werden nur von der Klasse DatabaseConnector erstellt.
+ * Die Klasse verfuegt ueber keinen oeffentlichen Konstruktor.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version 2015-01-31
+ */
+public class QueryResult{
+  private String[][] data;
+  private String[] columnNames;
+  private String[] columnTypes;
+
+  /**
+   * Paketinterner Konstruktor.
+   */
+  QueryResult(String[][] pData, String[] pColumnNames, String[] pColumnTypes){
+    data = pData;
+    columnNames = pColumnNames;
+    columnTypes = pColumnTypes;
+  }
+
+  /**
+   * Die Anfrage liefert die Eintraege der Ergebnistabelle als zweidimensionales Feld
+   * vom Typ String. Der erste Index des Feldes stellt die Zeile und der zweite die
+   * Spalte dar (d.h. Object[zeile][spalte]).
+   */
+  public String[][] getData(){
+    return data;
+  }
+
+  /**
+   * Die Anfrage liefert die Bezeichner der Spalten der Ergebnistabelle als Feld vom
+   * Typ String zurueck.
+   */
+  public String[] getColumnNames(){
+    return columnNames;
+  }
+
+  /**
+   * Die Anfrage liefert die Typenbezeichnung der Spalten der Ergebnistabelle als Feld
+   * vom Typ String zurueck. Die Bezeichnungen entsprechen den Angaben in der MySQL-Datenbank.
+   */
+  public String[] getColumnTypes(){
+    return columnTypes;
+  }
+
+  /**
+   * Die Anfrage liefert die Anzahl der Zeilen der Ergebnistabelle als Integer.
+   */
+  public int getRowCount(){
+    if (data != null )
+      return data.length;
+    else
+      return 0;
+  }
+
+  /**
+   * Die Anfrage liefert die Anzahl der Spalten der Ergebnistabelle als Integer.
+   */
+  public int getColumnCount(){
+    if (data != null && data.length > 0 && data[0] != null)
+      return data[0].length;
+    else
+      return 0;
+  }
+
+}

src/test/java/schule/ngb/zm/util/abi/Queue.java

@@ -0,0 +1,144 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse Queue<ContentType>
+ * </p>
+ * <p>
+ * Objekte der generischen Klasse Queue (Warteschlange) verwalten beliebige
+ * Objekte vom Typ ContentType nach dem First-In-First-Out-Prinzip, d.h., das
+ * zuerst abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden haben
+ * eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten Objekte.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_02 2014-02-21
+ */
+public class Queue<ContentType> {
+
+	/* --------- Anfang der privaten inneren Klasse -------------- */
+
+	private class QueueNode {
+
+		private ContentType content = null;
+		private QueueNode nextNode = null;
+
+		/**
+		 * Ein neues Objekt vom Typ QueueNode<ContentType> wird erschaffen.
+		 * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
+		 *
+		 * @param pContent das Inhaltselement des Knotens vom Typ ContentType
+		 */
+		public QueueNode(ContentType pContent) {
+			content = pContent;
+			nextNode = null;
+		}
+
+		/**
+		 * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
+		 * gesetzt.
+		 *
+		 * @param pNext der Nachfolger des Knotens
+		 */
+		public void setNext(QueueNode pNext) {
+			nextNode = pNext;
+		}
+
+		/**
+		 * Liefert das naechste Element des aktuellen Knotens.
+		 *
+		 * @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
+		 */
+		public QueueNode getNext() {
+			return nextNode;
+		}
+
+		/**
+		 * Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
+		 *
+		 * @return das Inhaltsobjekt des Knotens
+		 */
+		public ContentType getContent() {
+			return content;
+		}
+
+	}
+
+	/* ----------- Ende der privaten inneren Klasse -------------- */
+
+	private QueueNode head;
+	private QueueNode tail;
+
+	/**
+	 * Eine leere Schlange wird erzeugt.
+	 * Objekte, die in dieser Schlange verwaltet werden, muessen vom Typ
+	 * ContentType sein.
+	 */
+	public Queue() {
+		head = null;
+		tail = null;
+	}
+
+	/**
+	 * Die Anfrage liefert den Wert true, wenn die Schlange keine Objekte enthaelt,
+	 * sonst liefert sie den Wert false.
+	 *
+	 * @return true, falls die Schlange leer ist, sonst false
+	 */
+	public boolean isEmpty() {
+		return head == null;
+	}
+
+	/**
+	 * Das Objekt pContentType wird an die Schlange angehaengt.
+	 * Falls pContentType gleich null ist, bleibt die Schlange unveraendert.
+	 *
+	 * @param pContent
+	 *            das anzuhaengende Objekt vom Typ ContentType
+	 */
+	public void enqueue(ContentType pContent) {
+		if (pContent != null) {
+			QueueNode newNode = new QueueNode(pContent);
+			if (this.isEmpty()) {
+				head = newNode;
+				tail = newNode;
+			} else {
+				tail.setNext(newNode);
+				tail = newNode;
+			}
+		}
+	}
+
+	/**
+	 * Das erste Objekt wird aus der Schlange entfernt.
+	 * Falls die Schlange leer ist, wird sie nicht veraendert.
+	 */
+	public void dequeue() {
+		if (!this.isEmpty()) {
+			head = head.getNext();
+			if (this.isEmpty()) {
+				head = null;
+				tail = null;
+			}
+		}
+	}
+
+	/**
+	 * Die Anfrage liefert das erste Objekt der Schlange.
+	 * Die Schlange bleibt unveraendert.
+	 * Falls die Schlange leer ist, wird null zurueckgegeben.
+	 *
+	 * @return das erste Objekt der Schlange vom Typ ContentType oder null,
+	 *         falls die Schlange leer ist
+	 */
+	public ContentType front() {
+		if (this.isEmpty()) {
+			return null;
+		} else {
+			return head.getContent();
+		}
+	}
+}

src/test/java/schule/ngb/zm/util/abi/Server.java

@@ -0,0 +1,359 @@
+package schule.ngb.zm.util.abi; /**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Server
+ * </p>
+ * <p>
+ * Objekte von Unterklassen der abstrakten Klasse Server ermoeglichen das
+ * Anbieten von Serverdiensten, so dass Clients Verbindungen zum Server mittels
+ * TCP/IP-Protokoll aufbauen koennen. Zur Vereinfachung finden Nachrichtenversand
+ * und -empfang zeilenweise statt, d. h., beim Senden einer Zeichenkette wird ein
+ * Zeilentrenner ergaenzt und beim Empfang wird dieser entfernt.
+ * Verbindungsannahme, Nachrichtenempfang und Verbindungsende geschehen
+ * nebenlaeufig. Auf diese Ereignisse muss durch Ueberschreiben der entsprechenden
+ * Ereignisbehandlungsmethoden reagiert werden. Es findet nur eine rudimentaere
+ * Fehlerbehandlung statt, so dass z.B. Verbindungsabbrueche nicht zu einem
+ * Programmabbruch fuehren. Einmal unterbrochene oder getrennte Verbindungen
+ * koennen nicht reaktiviert werden.
+  * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version 30.08.2016
+ */
+import java.net.*;
+import java.io.*;
+
+public abstract class Server
+{
+    private NewConnectionHandler connectionHandler;
+    private List<ClientMessageHandler> messageHandlers;
+
+    private class NewConnectionHandler extends Thread
+    {
+        private ServerSocket serverSocket;
+        private boolean active;
+
+        public NewConnectionHandler(int pPort)
+        {
+            try
+            {
+                serverSocket = new ServerSocket(pPort);
+                start();
+                active = true;
+            }
+            catch (Exception e)
+            {
+                serverSocket = null;
+                active = false;
+            }
+        }
+
+        public void run()
+        {
+            while (active)
+            {
+                try
+                {
+                    //Warten auf Verbdinungsversuch durch Client:
+                    Socket clientSocket = serverSocket.accept();
+                    // Eingehende Nachrichten vom neu verbundenen Client werden
+                    // in einem eigenen Thread empfangen:
+                    addNewClientMessageHandler(clientSocket);
+                    processNewConnection(clientSocket.getInetAddress().getHostAddress(),clientSocket.getPort());
+                }
+
+                catch (IOException e)
+                {
+                    /*
+                     * Kann keine Verbindung zum anfragenden Client aufgebaut werden,
+                     * geschieht nichts.
+                     */
+                }
+            }
+        }
+
+        public void close()
+        {
+            active = false;
+            if(serverSocket != null)
+                try
+                {
+                    serverSocket.close();
+                }
+                catch (IOException e)
+                {
+                    /*
+                     * Befindet sich der ServerSocket im accept()-Wartezustand oder wurde
+                     * er bereits geschlossen, geschieht nichts.
+                     */
+                }
+        }
+    }
+
+    private class ClientMessageHandler extends Thread
+    {
+        private ClientSocketWrapper socketWrapper;
+        private boolean active;
+
+        private class ClientSocketWrapper
+        {
+            private Socket clientSocket;
+            private BufferedReader fromClient;
+            private PrintWriter toClient;
+
+            public ClientSocketWrapper(Socket pSocket)
+            {
+                try
+                {
+                    clientSocket = pSocket;
+                    toClient = new PrintWriter(clientSocket.getOutputStream(), true);
+                    fromClient = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+                }
+                catch (IOException e)
+                {
+                    clientSocket = null;
+                    toClient = null;
+                    fromClient = null;
+                }
+            }
+
+            public String receive()
+            {
+                if(fromClient != null)
+                    try
+                    {
+                        return fromClient.readLine();
+                    }
+                    catch (IOException e)
+                    {
+                    }
+                return(null);
+            }
+
+            public void send(String pMessage)
+            {
+                if(toClient != null)
+                {
+                    toClient.println(pMessage);
+                }
+            }
+
+            public String getClientIP()
+            {
+                if(clientSocket != null)
+                    return(clientSocket.getInetAddress().getHostAddress());
+                else
+                    return(null); //Gemaess Java-API Rueckgabe bei nicht-verbundenen Sockets
+            }
+
+            public int getClientPort()
+            {
+                if(clientSocket != null)
+                    return(clientSocket.getPort());
+                else
+                    return(0); //Gemaess Java-API Rueckgabe bei nicht-verbundenen Sockets
+            }
+
+            public void close()
+            {
+                if(clientSocket != null)
+                    try
+                    {
+                        clientSocket.close();
+                    }
+                    catch (IOException e)
+                    {
+                        /*
+                         * Falls eine Verbindung getrennt werden soll, deren Endpunkt
+                         * nicht mehr existiert bzw. ihrerseits bereits beendet worden ist,
+                         * geschieht nichts.
+                         */
+                    }
+            }
+        }
+
+        private ClientMessageHandler(Socket pClientSocket)
+        {
+            socketWrapper = new ClientSocketWrapper(pClientSocket);
+            if(pClientSocket!=null)
+            {
+                start();
+                active = true;
+            }
+            else
+            {
+                active = false;
+            }
+        }
+
+        public void run()
+        {
+            String message = null;
+            while (active)
+            {
+                message = socketWrapper.receive();
+                if (message != null)
+                    processMessage(socketWrapper.getClientIP(), socketWrapper.getClientPort(), message);
+                else
+                {
+                    ClientMessageHandler aMessageHandler = findClientMessageHandler(socketWrapper.getClientIP(), socketWrapper.getClientPort());
+                    if (aMessageHandler != null)
+                    {
+                        aMessageHandler.close();
+                        removeClientMessageHandler(aMessageHandler);
+                        processClosingConnection(socketWrapper.getClientIP(), socketWrapper.getClientPort());
+                    }
+                }
+            }
+        }
+
+        public void send(String pMessage)
+        {
+            if(active)
+                socketWrapper.send(pMessage);
+        }
+
+        public void close()
+        {
+            if(active)
+            {
+                active=false;
+                socketWrapper.close();
+            }
+        }
+
+        public String getClientIP()
+        {
+            return(socketWrapper.getClientIP());
+        }
+
+        public int getClientPort()
+        {
+            return(socketWrapper.getClientPort());
+        }
+
+    }
+
+    public Server(int pPort)
+    {
+        connectionHandler = new NewConnectionHandler(pPort);
+        messageHandlers = new List<ClientMessageHandler>();
+    }
+
+    public boolean isOpen()
+    {
+    	return(connectionHandler.active);
+    }
+
+    public boolean isConnectedTo(String pClientIP, int pClientPort)
+    {
+    	 ClientMessageHandler aMessageHandler = findClientMessageHandler(pClientIP, pClientPort);
+         if (aMessageHandler != null)
+        	 return(aMessageHandler.active);
+         else
+        	 return(false);
+    }
+
+    public void send(String pClientIP, int pClientPort, String pMessage)
+    {
+        ClientMessageHandler aMessageHandler = this.findClientMessageHandler(pClientIP, pClientPort);
+        if (aMessageHandler != null)
+            aMessageHandler.send(pMessage);
+    }
+
+    public void sendToAll(String pMessage)
+    {
+    	synchronized(messageHandlers)
+    	{
+    		messageHandlers.toFirst();
+    		while (messageHandlers.hasAccess())
+    		{
+    			messageHandlers.getContent().send(pMessage);
+    			messageHandlers.next();
+    		}
+    	}
+    }
+
+    public void closeConnection(String pClientIP, int pClientPort)
+    {
+        ClientMessageHandler aMessageHandler = findClientMessageHandler(pClientIP, pClientPort);
+        if (aMessageHandler != null)
+        {
+            processClosingConnection(pClientIP, pClientPort);
+            aMessageHandler.close();
+            removeClientMessageHandler(aMessageHandler);
+        }
+
+    }
+
+    public void close()
+    {
+        connectionHandler.close();
+
+        synchronized(messageHandlers)
+        {
+        	ClientMessageHandler aMessageHandler;
+        	messageHandlers.toFirst();
+        	while (messageHandlers.hasAccess())
+        	{
+        		aMessageHandler = messageHandlers.getContent();
+        		processClosingConnection(aMessageHandler.getClientIP(), aMessageHandler.getClientPort());
+        		aMessageHandler.close();
+        		messageHandlers.remove();
+        	}
+        }
+
+    }
+    public abstract void processNewConnection(String pClientIP, int pClientPort);
+
+    public abstract void processMessage(String pClientIP, int pClientPort, String pMessage);
+
+    public abstract void processClosingConnection(String pClientIP, int pClientPort);
+
+    private void addNewClientMessageHandler(Socket pClientSocket)
+    {
+    	synchronized(messageHandlers)
+    	{
+    		messageHandlers.append(new ClientMessageHandler(pClientSocket));
+    	}
+    }
+
+    private void removeClientMessageHandler(ClientMessageHandler pClientMessageHandler)
+    {
+    	synchronized(messageHandlers)
+    	{
+    		messageHandlers.toFirst();
+    		while (messageHandlers.hasAccess())
+    		{
+    			if (pClientMessageHandler ==  messageHandlers.getContent())
+    			{
+    				messageHandlers.remove();
+    				return;
+    			}
+    			else
+    				messageHandlers.next();
+    		}
+    	}
+    }
+
+    private ClientMessageHandler findClientMessageHandler(String pClientIP, int pClientPort)
+    {
+    	synchronized(messageHandlers)
+    	{
+    		ClientMessageHandler aMessageHandler;
+    		messageHandlers.toFirst();
+
+    		while (messageHandlers.hasAccess())
+    		{
+    			aMessageHandler = messageHandlers.getContent();
+    			if (aMessageHandler.getClientIP().equals(pClientIP) && aMessageHandler.getClientPort() == pClientPort)
+    				return (aMessageHandler);
+    			messageHandlers.next();
+    		}
+    		return (null);
+    	}
+    }
+
+}

src/test/java/schule/ngb/zm/util/abi/Stack.java

@@ -0,0 +1,128 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse Stack<ContentType>
+ * </p>
+ * <p>
+ * Objekte der generischen Klasse Stack (Keller, Stapel) verwalten beliebige
+ * Objekte vom Typ ContentType nach dem Last-In-First-Out-Prinzip, d.h., das
+ * zuletzt abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden
+ * haben eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten
+ * Objekte.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_02 2014-02-21
+ */
+public class Stack<ContentType> {
+
+  /* --------- Anfang der privaten inneren Klasse -------------- */
+
+  private class StackNode {
+
+    private ContentType content = null;
+    private StackNode nextNode = null;
+
+    /**
+     * Ein neues Objekt vom Typ StackNode<ContentType> wird erschaffen. <br />
+     * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
+     *
+     * @param pContent der Inhalt des Knotens
+     */
+    public StackNode(ContentType pContent) {
+      content = pContent;
+      nextNode = null;
+    }
+
+    /**
+     * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
+     * gesetzt.
+     *
+     * @param pNext der Nachfolger des Knotens
+     */
+    public void setNext(StackNode pNext) {
+      nextNode = pNext;
+    }
+
+    /**
+     *
+     * @return das Objekt, auf das der aktuelle Verweis zeigt
+     */
+    public StackNode getNext() {
+      return nextNode;
+    }
+
+    /**
+     * @return das Inhaltsobjekt vom Typ ContentType
+     */
+    public ContentType getContent() {
+      return content;
+    }
+  }
+
+  /* ----------- Ende der privaten inneren Klasse -------------- */
+
+  private StackNode head;
+
+  /**
+   * Ein leerer Stapel wird erzeugt. Objekte, die in diesem Stapel verwaltet
+   * werden, muessen vom Typ ContentType sein.
+   */
+  public Stack() {
+    head = null;
+  }
+
+  /**
+   * Die Anfrage liefert den Wert true, wenn der Stapel keine Objekte
+   * enthaelt, sonst liefert sie den Wert false.
+   *
+   * @return true, falls der Stapel leer ist, sonst false
+   */
+  public boolean isEmpty() {
+    return (head == null);
+  }
+
+  /**
+   * Das Objekt pContentType wird oben auf den Stapel gelegt. Falls
+   * pContentType gleich null ist, bleibt der Stapel unveraendert.
+   *
+   * @param pContent
+   *        das einzufuegende Objekt vom Typ ContentType
+   */
+  public void push(ContentType pContent) {
+    if (pContent != null) {
+      StackNode node = new StackNode(pContent);
+      node.setNext(head);
+      head = node;
+    }
+  }
+
+  /**
+   * Das zuletzt eingefuegte Objekt wird von dem Stapel entfernt. Falls der
+   * Stapel leer ist, bleibt er unveraendert.
+   */
+  public void pop() {
+    if (!isEmpty()) {
+      head = head.getNext();
+    }
+  }
+
+  /**
+   * Die Anfrage liefert das oberste Stapelobjekt. Der Stapel bleibt
+   * unveraendert. Falls der Stapel leer ist, wird null zurueckgegeben.
+   *
+   * @return das oberste Stackelement vom Typ ContentType oder null, falls
+   *         der Stack leer ist
+   */
+  public ContentType top() {
+    if (!this.isEmpty()) {
+      return head.getContent();
+    } else {
+      return null;
+    }
+  }
+}

src/test/java/schule/ngb/zm/util/abi/Vertex.java

@@ -0,0 +1,53 @@
+package schule.ngb.zm.util.abi;
+
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Klasse Vertex
+ * </p>
+ * <p>
+ * Die Klasse Vertex stellt einen einzelnen Knoten eines Graphen dar. Jedes Objekt
+ * dieser Klasse verfuegt ueber eine im Graphen eindeutige ID als String und kann diese
+ * ID zurueckliefern. Darueber hinaus kann eine Markierung gesetzt und abgefragt werden.
+ * </p>
+ *
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Oktober 2015
+ */
+public class Vertex{
+  //Einmalige ID des Knotens und Markierung
+  private String id;
+  private boolean mark;
+
+  /**
+  * Ein neues Objekt vom Typ Vertex wird erstellt. Seine Markierung hat den Wert false.
+  */
+  public Vertex(String pID){
+    id = pID;
+    mark = false;
+  }
+
+  /**
+  * Die Anfrage liefert die ID des Knotens als String.
+  */
+  public String getID(){
+    return new String(id);
+  }
+
+  /**
+  * Der Auftrag setzt die Markierung des Knotens auf den Wert pMark.
+  */
+  public void setMark(boolean pMark){
+    mark = pMark;
+  }
+
+  /**
+  * Die Anfrage liefert true, wenn die Markierung des Knotens den Wert true hat, ansonsten false.
+  */
+  public boolean isMarked(){
+    return mark;
+  }
+
+}

src/test/java/schule/ngb/zm/util/test/ImageAssertions.java

@@ -0,0 +1,165 @@
+package schule.ngb.zm.util.test;
+
+import org.junit.jupiter.api.Assertions;
+import org.opentest4j.AssertionFailedError;
+import schule.ngb.zm.util.io.ImageLoader;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.function.Supplier;
+
+public final class ImageAssertions {
+
+	private static boolean SAVE_DIFF_IMAGE_ON_FAIL = false;
+
+	private static File DIFF_IMAGE_PATH = new File("build/test-results/diff");
+
+	private static AssertionFailedError ASSERTION_FAILED_ERROR = null;
+
+
+	public static boolean isSaveDiffImageOnFail() {
+		return SAVE_DIFF_IMAGE_ON_FAIL;
+	}
+
+	public static final void setSaveDiffImageOnFail( boolean saveOnFail ) {
+		SAVE_DIFF_IMAGE_ON_FAIL = saveOnFail;
+	}
+
+	public static File getDiffImagePath() {
+		return DIFF_IMAGE_PATH;
+	}
+
+	public static void assertEquals( BufferedImage expected, BufferedImage actual ) {
+		assertEquals(expected, actual, () -> "Actual image differs from expected buffer.");
+	}
+
+	public static void assertEquals( BufferedImage expected, BufferedImage actual, String message ) {
+		assertEquals(expected, actual, () -> message);
+	}
+
+	public static void assertEquals( BufferedImage expected, BufferedImage actual, Supplier<String> messageSupplier ) {
+		// Compare image dimensions
+		int expectedHeight = expected.getHeight(), expectedWidth = expected.getWidth();
+		int actualHeight = actual.getHeight(), actualWidth = actual.getWidth();
+		try {
+			Assertions.assertEquals(expectedHeight, actualHeight);
+			Assertions.assertEquals(expectedWidth, actualWidth);
+		} catch( AssertionFailedError afe ) {
+			ASSERTION_FAILED_ERROR = afe;
+			fail(expected, actual, messageSupplier);
+		}
+
+		// TODO: Fix comparison of transparent pixels
+		for( int x = 0; x < actualWidth; x++ ) {
+			for( int y = 0; y < actualHeight; y++ ) {
+				try {
+					Assertions.assertTrue(comparePixels(expected.getRGB(x, y), actual.getRGB(x, y)));
+				} catch( AssertionFailedError afe ) {
+					ASSERTION_FAILED_ERROR = afe;
+					fail(expected, actual, messageSupplier);
+				}
+			}
+		}
+	}
+
+	public static void assertNotEquals( BufferedImage expected, BufferedImage actual ) {
+		assertNotEquals(expected, actual, () -> "Actual image is the same as expected buffer.");
+	}
+
+	public static void assertNotEquals( BufferedImage expected, BufferedImage actual, String message ) {
+		assertNotEquals(expected, actual, () -> message);
+	}
+
+	public static void assertNotEquals( BufferedImage expected, BufferedImage actual, Supplier<String> messageSupplier ) {
+		// Compare image dimensions
+		int expectedHeight = expected.getHeight(), expectedWidth = expected.getWidth();
+		int actualHeight = actual.getHeight(), actualWidth = actual.getWidth();
+		if( expectedHeight != actualHeight || expectedWidth != actualWidth ) {
+			// Image dimensions differ, assertion is true
+			return;
+		}
+
+		for( int x = 0; x < actualWidth; x++ ) {
+			for( int y = 0; y < actualHeight; y++ ) {
+				if( !comparePixels(expected.getRGB(x, y), actual.getRGB(x, y)) ) {
+					// Found different pixels, assertion is true
+					return;
+				}
+			}
+		}
+
+		// Images are the same, fail without diff
+		fail(expected, actual, messageSupplier, false);
+	}
+
+	private static void fail( BufferedImage expected, BufferedImage actual, Supplier<String> messageSupplier ) {
+		fail(expected, actual, messageSupplier, SAVE_DIFF_IMAGE_ON_FAIL);
+	}
+
+	private static void fail( BufferedImage expected, BufferedImage actual, Supplier<String> messageSupplier, boolean saveDiffImage ) {
+		if( saveDiffImage ) {
+			saveDiffImage(expected, actual);
+		}
+		throw new AssertionFailedError(
+			messageSupplier != null ? messageSupplier.get() : null,
+			ASSERTION_FAILED_ERROR
+		);
+	}
+
+	private static boolean comparePixels( int a, int b ) {
+		// TODO: Fix comparison of transparent pixels
+		return a == b || ((0xFF000000 & a) == 0 && (0xFF000000 & b) == 0);
+	}
+
+	public static BufferedImage createDiffImage( BufferedImage expected, BufferedImage actual ) {
+		// Error color (white)
+		int errorColor = 0xFF00FF;
+
+		int expectedHeight = expected.getHeight(), expectedWidth = expected.getWidth();
+		int actualHeight = actual.getHeight(), actualWidth = actual.getWidth();
+		int maxHeight = Math.max(expectedHeight, actualHeight), maxWidth = Math.max(expectedWidth, actualWidth);
+
+		BufferedImage diff = ImageLoader.createImage(maxWidth, maxHeight);
+		for( int x = 0; x < maxWidth; x++ ) {
+			for( int y = 0; y < maxHeight; y++ ) {
+				diff.setRGB(x, y, 0);
+				if( x > actualWidth || y > actualHeight || x > expectedWidth || y > expectedHeight ) {
+					// Set overflow pixels to error color
+					diff.setRGB(x, y, errorColor);
+				} else if( !comparePixels(actual.getRGB(x, y), expected.getRGB(x, y)) ) {
+					// Set differences to error color
+					// If both pixels are transparent, the color dows not matter ...
+					// TODO: saturate error color based on how different the colors are?
+					diff.setRGB(x, y, errorColor);
+				}
+			}
+		}
+
+		return diff;
+	}
+
+	public static boolean saveDiffImage( BufferedImage expected, BufferedImage actual ) {
+		BufferedImage diff = createDiffImage(expected, actual);
+		try {
+			File diffFile = new File(DIFF_IMAGE_PATH, makeDiffName());
+			if( !diffFile.getParentFile().exists() ) {
+				diffFile.mkdirs();
+			}
+			ImageLoader.saveImage(diff, diffFile);
+		} catch( IOException ioe ) {
+			// We fail anyways at this point
+			// TODO: Log something?
+			return false;
+		}
+		return true;
+	}
+
+	private static String makeDiffName() {
+		return System.currentTimeMillis() + ".png";
+	}
+
+	private ImageAssertions() {
+	}
+
+}

src/test/java/schule/ngb/zm/util/test/TestEnv.java

@@ -0,0 +1,25 @@
+package schule.ngb.zm.util.test;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import schule.ngb.zm.Testmaschine;
+import schule.ngb.zm.Zeichenmaschine;
+
+public class TestEnv implements ParameterResolver {
+
+	@Override
+	public boolean supportsParameter( ParameterContext parameterContext, ExtensionContext extensionContext ) throws ParameterResolutionException {
+		return (
+			parameterContext.getParameter().getType() == Zeichenmaschine.class ||
+				parameterContext.getParameter().getType() == Testmaschine.class
+		);
+	}
+
+	@Override
+	public Object resolveParameter( ParameterContext parameterContext, ExtensionContext extensionContext ) throws ParameterResolutionException {
+		return new Testmaschine();
+	}
+
+}