Initialer Commit

xxx-domain/.classpath

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/main/resources"/>
+	<classpathentry kind="src" path="src/main/testdaten"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="lib" path="lib/codemodel.jar"/>
+	<classpathentry kind="lib" path="lib/dtd-parser.jar"/>
+	<classpathentry kind="lib" path="lib/FastInfoset.jar"/>
+	<classpathentry kind="lib" path="lib/istack-commons-runtime.jar"/>
+	<classpathentry kind="lib" path="lib/istack-commons-tools.jar"/>
+	<classpathentry kind="lib" path="lib/javax.activation-api.jar"/>
+	<classpathentry kind="lib" path="lib/jaxb-api.jar"/>
+	<classpathentry kind="lib" path="lib/jaxb-jxc.jar"/>
+	<classpathentry kind="lib" path="lib/jaxb-runtime.jar"/>
+	<classpathentry kind="lib" path="lib/jaxb-xjc.jar"/>
+	<classpathentry kind="lib" path="lib/relaxng-datatype.jar"/>
+	<classpathentry kind="lib" path="lib/rngom.jar"/>
+	<classpathentry kind="lib" path="lib/stax-ex.jar"/>
+	<classpathentry kind="lib" path="lib/txw2.jar"/>
+	<classpathentry kind="lib" path="lib/xsom.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

xxx-domain/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>xxx-domain</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

xxx-domain/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

xxx-domain/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,14 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=17

xxx-domain/src/main/java/de/stoermer/xxx/domain/Anzeige.java

@@ -0,0 +1,6 @@
+package de.stoermer.xxx.domain;
+
+public interface Anzeige {
+
+	public String anzeigeText();
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/Beschreibung.java

@@ -0,0 +1,7 @@
+package de.stoermer.xxx.domain;
+
+public interface Beschreibung {
+	
+	public String beschreibungsText();
+
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/Geschlecht.java

@@ -0,0 +1,19 @@
+package de.stoermer.xxx.domain;
+
+public enum Geschlecht implements Anzeige {
+
+	MAENNLICH("Männlich"),
+	WEIBLICH("Weiblich"),
+	DIVERS("Divers");
+
+	private String anzeige;
+
+	Geschlecht(String anzeige) {
+		this.anzeige = anzeige;
+	}
+	
+	@Override
+	public String anzeigeText() {
+		return anzeige;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/InkonsistenterAufgabenZustand.java

@@ -0,0 +1,10 @@
+package de.stoermer.xxx.domain;
+
+public class InkonsistenterAufgabenZustand extends Exception {
+
+	private static final long serialVersionUID = 1L;
+
+	public InkonsistenterAufgabenZustand(String message) {
+		super(message);
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/InkonsistenterSpielerZustand.java

@@ -0,0 +1,10 @@
+package de.stoermer.xxx.domain;
+
+public class InkonsistenterSpielerZustand extends Exception{
+
+	private static final long serialVersionUID = 1L;
+
+	public InkonsistenterSpielerZustand(String message) {
+		super(message);
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/Rolle.java

@@ -0,0 +1,27 @@
+package de.stoermer.xxx.domain;
+
+public enum Rolle implements Anzeige, Beschreibung {
+
+	BESTRAFENDE_PERSON("Bestrafende Person", "Die Person darf andere Personen bestrafen."),
+	BESTRAFTE_PERSON("Bestrafte Person", "Die Person empfängt Strafen von anderen."),
+	BEGLUECKENDE_PERSON("Beglückende Person", "Die Person darf andere Personen beglücken."),
+	BEGLUECKTE_PERSON("Beglückte Person", "Die Person wird von anderen Personen beglückt.");
+	
+	private String anzeige;
+	private String beschreibung;
+
+	private Rolle(String anzeige, String beschreibungs) {
+		this.anzeige = anzeige;
+		this.beschreibung = beschreibungs;
+	}
+	
+	@Override
+	public String anzeigeText() {
+		return anzeige;
+	}
+	
+	@Override
+	public String beschreibungsText() {
+		return beschreibung;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/SchablonenProvider.java

@@ -0,0 +1,18 @@
+package de.stoermer.xxx.domain;
+
+import java.util.List;
+
+import de.stoermer.xxx.domain.aufgaben.BeglueckungSchablone;
+import de.stoermer.xxx.domain.aufgaben.BestrafungSchablone;
+import de.stoermer.xxx.domain.aufgaben.LockSchablone;
+
+public interface SchablonenProvider {
+
+	List<LockSchablone> getSperren();
+
+	List<BeglueckungSchablone> getBeglueckungen();
+
+	List<BestrafungSchablone> getStrafen();
+
+	List<de.stoermer.xxx.domain.Toy> getToys();
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/Session.java

@@ -0,0 +1,215 @@
+package de.stoermer.xxx.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import de.stoermer.xxx.domain.aufgaben.AlleLocksVerlaengern;
+import de.stoermer.xxx.domain.aufgaben.Aufgabe;
+import de.stoermer.xxx.domain.aufgaben.BeglueckungSchablone;
+import de.stoermer.xxx.domain.aufgaben.BestrafungSchablone;
+import de.stoermer.xxx.domain.aufgaben.LockSchablone;
+import de.stoermer.xxx.domain.aufgaben.RumMachen;
+import de.stoermer.xxx.domain.aufgaben.UltimativeStrafe;
+
+public class Session {
+
+	private List<Spieler> spieler;
+	private int wahrscheinlichkeitSperre; // 0 - 100;
+	private int wahrscheinlichkeitStrafe; // 0 - 100;
+	
+	private List<LockSchablone> sperren;
+	private List<BeglueckungSchablone> beglueckungen;
+	private List<BestrafungSchablone> strafen;
+	
+	private int aufgabeAufAktuellenLevel = 0;
+	private int aufgabenProLevel = 10;
+	private int level = 1;
+	
+	public Session(List<Spieler> spieler, int wahrscheinlichkeitSperre, int wahrscheinlichkeitStrafe,
+			List<Toy> toys, int aufgabenProLevel, SchablonenProvider schablonenProvider) throws InkonsistenterSpielerZustand, InkonsistenterAufgabenZustand {
+		this.spieler = spieler;
+		this.wahrscheinlichkeitSperre = wahrscheinlichkeitSperre;
+		this.wahrscheinlichkeitStrafe = wahrscheinlichkeitStrafe;
+		this.sperren = schablonenProvider.getSperren().stream().filter(sperre -> sperre.moeglich(toys)).toList();
+		this.beglueckungen = schablonenProvider.getBeglueckungen().stream().filter(sperre -> sperre.moeglich(toys)).toList();
+		this.strafen = schablonenProvider.getStrafen().stream().filter(sperre -> sperre.moeglich(toys)).toList();
+		this.aufgabenProLevel = aufgabenProLevel;
+		
+		checkSpieler();
+		cehckAufgabe();
+	}
+	
+	private void cehckAufgabe() throws InkonsistenterAufgabenZustand {
+		if (sperren.isEmpty() && strafen.isEmpty() && beglueckungen.isEmpty()) {
+			throw new InkonsistenterAufgabenZustand("Ein Spiel ohne Aufgaben macht wenig Sinn...");
+		}
+	}
+
+	private void checkSpieler() throws InkonsistenterSpielerZustand {
+		for (Spieler spieler : spielerMitRolle(Rolle.BESTRAFTE_PERSON)) {
+			if (spielerMitRolleAußer(Rolle.BESTRAFENDE_PERSON, spieler) == null) {
+				throw new InkonsistenterSpielerZustand(spieler.getName() + " verfügt über keine Person, die sie/ihn bestrafen kann");
+			}
+		}
+		for (Spieler spieler : spielerMitRolle(Rolle.BESTRAFENDE_PERSON)) {
+			if (spielerMitRolleAußer(Rolle.BESTRAFTE_PERSON, spieler) == null) {
+				throw new InkonsistenterSpielerZustand(spieler.getName() + " verfügt über keine Person, die sie/er bestrafen kann");
+			}
+		}
+		for (Spieler spieler : spielerMitRolle(Rolle.BEGLUECKTE_PERSON)) {
+			if (spielerMitRolleAußer(Rolle.BEGLUECKENDE_PERSON, spieler) == null) {
+				throw new InkonsistenterSpielerZustand(spieler.getName() + " verfügt über keine Person, die sie/ihn beglücken kann");
+			}
+		}
+		for (Spieler spieler : spielerMitRolle(Rolle.BEGLUECKENDE_PERSON)) {
+			if (spielerMitRolleAußer(Rolle.BEGLUECKTE_PERSON, spieler) == null) {
+				throw new InkonsistenterSpielerZustand(spieler.getName() + " verfügt über keine Person, die sie/ihn beglücken kann");
+			}
+		}
+	}
+
+	public List<Spieler> spielerMitRolle(Rolle rolle) {
+		return spieler.stream().filter(s -> s.getRollen().contains(rolle)).toList();
+	}
+	
+	public Spieler spielerMitRolleAußer(Rolle rolle, Spieler ausschluss) {
+		List<Spieler> list = spieler.stream().filter(spieler -> spieler != ausschluss && spieler.getRollen().contains(rolle)).toList();
+		if (list != null && list.size() > 0) {
+			return list.get(new Random().nextInt(list.size()));
+		}
+		return null;
+	}
+	
+	public Aufgabe naechsteAufgabe() {
+		System.out.println("Aktuelles Level: " + level);
+		System.out.println("Vor neuer Aufgabe: ");
+		logStatus();
+		Random random = new Random();
+		int nextInt = random.nextInt(100);
+		System.out.println("Random Wert: " + nextInt);
+		if (nextInt == 1) {
+			List<Spieler> bestraftePersonen = spielerMitRolle(Rolle.BESTRAFTE_PERSON);
+			if (bestraftePersonen != null && !bestraftePersonen.isEmpty()) {
+				Spieler bestraftePerson = bestraftePersonen.get(random.nextInt(bestraftePersonen.size()));
+				Spieler bestrafendePerson = spielerMitRolleAußer(Rolle.BESTRAFENDE_PERSON, bestraftePerson);
+				return new UltimativeStrafe(bestraftePerson, bestrafendePerson);
+			}
+			
+		} 
+		if (nextInt == 2) {
+			List<Spieler> bestraftePersonen = spielerMitRolle(Rolle.BESTRAFTE_PERSON);
+			if (bestraftePersonen != null && !bestraftePersonen.isEmpty()) {				
+				Spieler bestraftePerson = bestraftePersonen.get(random.nextInt(bestraftePersonen.size()));
+				Spieler bestrafendePerson = spielerMitRolleAußer(Rolle.BESTRAFENDE_PERSON, bestraftePerson);
+				return new AlleLocksVerlaengern(bestraftePerson, bestrafendePerson);
+			}	
+		}
+		if (nextInt < 2 + wahrscheinlichkeitSperre) {
+			System.out.println("Wahrscheinlichkeit Sperre");
+			List<Spieler> spielerMitRolle = new ArrayList<>(spielerMitRolle(Rolle.BESTRAFTE_PERSON));
+			Collections.shuffle(spielerMitRolle);
+			for (Spieler weggesperrtePerson : spielerMitRolle) {
+				List<Werkzeug> wegsperrbareWerkzeuge = new ArrayList<>(weggesperrtePerson.wegsperrbareWerkzeuge());
+				Collections.shuffle(wegsperrbareWerkzeuge);
+				for (Werkzeug werkzeug : wegsperrbareWerkzeuge) {
+					List<LockSchablone> potentielleSperren = sperren.stream().filter(sperre -> sperre.getWerkzeug() == werkzeug).toList();
+					if (potentielleSperren != null && !potentielleSperren.isEmpty()) {
+						LockSchablone lockSchablone = potentielleSperren.get(random.nextInt(potentielleSperren.size()));						
+						Spieler keyHolder = spielerMitRolleAußer(Rolle.BESTRAFENDE_PERSON, weggesperrtePerson);
+						return lockSchablone.neuesLock(weggesperrtePerson, keyHolder);
+					}
+				}
+			}
+		} 
+		if (nextInt < 2 + wahrscheinlichkeitSperre + wahrscheinlichkeitStrafe) {
+			System.out.println("Wahrscheinlichkeit Strafe");
+			List<Spieler> spielerMitRolle = spielerMitRolle(Rolle.BESTRAFTE_PERSON);
+			if (spielerMitRolle != null && !spielerMitRolle.isEmpty()) {
+				Spieler bestraftePerson = spielerMitRolle.get(random.nextInt(spielerMitRolle.size()));
+				Spieler bestrafendePerson = spielerMitRolleAußer(Rolle.BESTRAFENDE_PERSON, bestraftePerson);
+				if (bestrafendePerson != null && bestraftePerson != null) {
+					List<BestrafungSchablone> potentielleStrafen = strafen.stream().filter(strafe -> strafe.isAusfuehrbar(bestraftePerson, bestrafendePerson, level)).toList();
+					if (potentielleStrafen != null && !potentielleStrafen.isEmpty()) {
+						BestrafungSchablone schablone = potentielleStrafen.get(random.nextInt(potentielleStrafen.size()));
+						checkLevel();
+						return schablone.neueBestrafung(bestraftePerson, bestrafendePerson);
+					}
+				}
+			}
+		}
+		System.out.println("Wähle Standard-Aufgabe");
+		List<Spieler> spielerMitRolle = spielerMitRolle(Rolle.BEGLUECKTE_PERSON);
+		if (spielerMitRolle != null && !spielerMitRolle.isEmpty()) {
+			Spieler begluecktePerson = spielerMitRolle.get(random.nextInt(spielerMitRolle.size()));
+			Spieler beglueckendePerson = spielerMitRolleAußer(Rolle.BEGLUECKENDE_PERSON, begluecktePerson);
+			if (beglueckendePerson != null) {
+				List<BeglueckungSchablone> potentielleBeglueckungen = beglueckungen.stream().filter(begl -> begl.isAusfuehrbar(begluecktePerson, beglueckendePerson, level)).toList();
+				if (potentielleBeglueckungen != null && !potentielleBeglueckungen.isEmpty()) {
+					BeglueckungSchablone schablone = potentielleBeglueckungen.get(random.nextInt(potentielleBeglueckungen.size()));
+					checkLevel();
+					return schablone.beglueckungAusSchablone(begluecktePerson, beglueckendePerson);
+				}
+			}
+		}
+		checkLevel();
+		return new RumMachen(spieler.get(0), spieler.get(1));
+	}
+	
+	private void checkLevel() {
+		if (++aufgabeAufAktuellenLevel >= aufgabenProLevel && level < 5) {
+			aufgabeAufAktuellenLevel = 0;
+			level++;
+		}
+	}
+	
+	private void logStatus() {
+		for (Spieler aSpieler : spieler ) {
+			aSpieler.logStauts();
+		}
+	}
+	
+	public List<String> pruefeLocks() {
+		List<String> result = new ArrayList<>();
+		spieler.forEach(spieler -> result.addAll(spieler.pruefeLocks()));
+		return result;
+	}
+	
+	public List<Spieler> getSpieler() {
+		return spieler;
+	}
+
+	public int getWahrscheinlichkeitSperre() {
+		return wahrscheinlichkeitSperre;
+	}
+
+	public int getWahrscheinlichkeitStrafe() {
+		return wahrscheinlichkeitStrafe;
+	}
+
+	public List<LockSchablone> getSperren() {
+		return sperren;
+	}
+
+	public List<BeglueckungSchablone> getBeglueckungen() {
+		return beglueckungen;
+	}
+
+	public List<BestrafungSchablone> getStrafen() {
+		return strafen;
+	}
+
+	public int getAufgabeAufAktuellenLevel() {
+		return aufgabeAufAktuellenLevel;
+	}
+
+	public int getAufgabenProLevel() {
+		return aufgabenProLevel;
+	}
+
+	public int getLevel() {
+		return level;
+	}
+}
+

xxx-domain/src/main/java/de/stoermer/xxx/domain/Spieler.java

@@ -0,0 +1,84 @@
+package de.stoermer.xxx.domain;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import de.stoermer.xxx.domain.aufgaben.Lock;
+
+public class Spieler {
+
+	private final String name;
+	private final Geschlecht geschlecht;
+	private final List<Rolle> rollen;
+	private final List<Werkzeug> werkzeuge;
+	
+	private Map<Werkzeug, Lock> currentLocks = new HashMap<>();
+	
+	public Spieler(String name, Geschlecht geschlecht, List<Rolle> rollen, List<Werkzeug> werkzeuge) {
+		this.name = name;
+		this.geschlecht = geschlecht;
+		this.rollen = Collections.unmodifiableList(rollen);
+		this.werkzeuge = Collections.unmodifiableList(werkzeuge);
+	}
+	
+	public String getName() {
+		return name;
+	}
+
+	public Geschlecht getGeschlecht() {
+		return geschlecht;
+	}
+
+	public List<Rolle> getRollen() {
+		return rollen;
+	}
+
+	public boolean istVerfuegbar(Werkzeug werkzeug) {
+		return werkzeuge.contains(werkzeug) && currentLocks.entrySet().stream().noneMatch(entry -> werkzeug == entry.getKey());
+	}
+	
+	public List<Werkzeug> wegsperrbareWerkzeuge() {
+		return werkzeuge.stream().filter(werkzeug -> currentLocks.entrySet().stream().noneMatch(entry -> werkzeug == entry.getKey())).toList();
+	}
+	
+	public void lock(Lock lock) {
+		currentLocks.put(lock.getWerkzeug(), lock);
+	}
+	
+	public List<String> pruefeLocks() {
+		List<Lock> unlock = currentLocks.entrySet().stream().filter(entry -> entry.getValue().getReleaseTime().isBefore(LocalDateTime.now())).map(entry -> entry.getValue()).toList();
+		unlock.forEach(lock -> currentLocks.remove(lock.getWerkzeug()));
+		return unlock.stream().map(lock -> lock.getReleaseText()).toList();
+	}
+	
+	public void lockVerlaengern(int times) {
+		currentLocks.entrySet().forEach(entry -> entry.getValue().verlaengern(times));
+	}
+	
+	@Override
+	public String toString() {
+		return name;
+	}
+	
+	public List<Werkzeug> getWerkzeuge() {
+		return werkzeuge;
+	}
+	
+	public Map<Werkzeug, Lock> getCurrentLocks() {
+		return currentLocks;
+	}
+	
+	public void logStauts() {
+		System.out.println("*---Spielerinfo---*");
+		System.out.println("Name: " + name);
+		System.out.println("Rollen:");
+		rollen.forEach(System.out::println);
+		System.out.println("Werkzeuge:");
+		werkzeuge.forEach(System.out::println);
+		System.out.println("Locks:");
+		currentLocks.entrySet().stream().map(entry -> entry.getValue()).forEach(System.out::println);
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/Toy.java

@@ -0,0 +1,50 @@
+package de.stoermer.xxx.domain;
+
+import java.util.Objects;
+
+public class Toy {
+
+	private String id;
+	private String beschreibung;
+
+	public String getBeschreibung() {
+		return beschreibung;
+	}
+
+	public void setBeschreibung(String beschreibung) {
+		this.beschreibung = beschreibung;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	public static Toy fromXml(de.stoermer.xxx.domain.xml.Toy xml) {
+		Toy toy = new Toy();
+		toy.setId(xml.getId());
+		toy.setBeschreibung(xml.getName());
+		return toy;
+	}
+	
+	@Override
+	public int hashCode() {
+		return Objects.hash(id);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Toy other = (Toy) obj;
+		return Objects.equals(id, other.id);
+	}
+
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/Werkzeug.java

@@ -0,0 +1,28 @@
+package de.stoermer.xxx.domain;
+
+public enum Werkzeug implements Anzeige, Beschreibung {
+	
+	MUND("Mund", "Ob die Person gewillt ist den Mund einzusetzen."),
+	VAGINA("Vagina", "Ob die Person über eine Vagina verfügt und gewillt ist diese einzusetzen."),
+	PENIS("Penis", "Ob die Person über einen Penis verfügt und gewillt ist diesen einzusetzen."),
+	ANUS("Anus", "Ob die Person gewillt ist den Anus einzusetzen."),
+	UMSCHNALLDILDO("Umschnall-Dildo", "Ob die Person über einen Umschnall-Dildo verfügt und gewillt ist diesen einzusetzen.");
+		
+	private String anzeige;
+	private String beschreibung;
+	
+	Werkzeug(String anzeige, String beschreibung) {
+		this.anzeige = anzeige;
+		this.beschreibung = beschreibung;
+	}
+	
+	@Override
+	public String beschreibungsText() {
+		return beschreibung;
+	}
+
+	@Override
+	public String anzeigeText() {
+		return anzeige;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/AlleLocksVerlaengern.java

@@ -0,0 +1,30 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.Random;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public class AlleLocksVerlaengern extends Aufgabe {
+
+	private static final String TEXT = "$SPIELER2, du entscheidest. Sollen alle bestehnden Zeitstrafen von $SPIELER1 verlängert werden...?";
+	
+	public AlleLocksVerlaengern(Spieler bestraftePerson, Spieler bestrafendePerson) {
+		super(bestraftePerson, bestrafendePerson, TEXT);
+	}
+	
+	@Override
+	public Timer getTimer() {
+		return null;
+	}
+
+	@Override
+	public void abbrechen() {
+		// Nix zu tun.
+	}
+
+	@Override
+	public void ok() {
+		int times = new Random().nextInt(2, 4);
+		getSpieler1().lockVerlaengern(times);
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/Aufgabe.java

@@ -0,0 +1,34 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public abstract class Aufgabe {
+	
+	private final Spieler spieler1; // Der bestrafte oder beglückte
+	private final Spieler spieler2; // Der Bestrafer oder Beglücker
+	private final String text;
+	
+	public Aufgabe(Spieler spieler1, Spieler spieler2, String text) {
+		this.spieler1 = spieler1;
+		this.spieler2 = spieler2;
+		this.text = text;
+	}
+
+	public String anzeigeText() {
+		return text.replace("$SPIELER1", spieler1.getName()).replace("$SPIELER2", spieler2.getName());
+	}
+
+	public abstract Timer getTimer();
+	
+	public abstract void ok();
+	
+	public abstract void abbrechen();
+
+	public Spieler getSpieler1() {
+		return spieler1;
+	}
+
+	public Spieler getSpieler2() {
+		return spieler2;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/Beglueckung.java

@@ -0,0 +1,20 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public class Beglueckung extends ZeitgesteuerteAufgabe {
+
+	public Beglueckung(Spieler spieler1, Spieler spieler2, String text, Integer timerSekunden) {
+		super(spieler1, spieler2, text, timerSekunden);
+	}
+
+	@Override
+	public void ok() {
+		
+	}
+
+	@Override
+	public void abbrechen() {
+		
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/BeglueckungSchablone.java

@@ -0,0 +1,75 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import de.stoermer.xxx.domain.Spieler;
+import de.stoermer.xxx.domain.Toy;
+import de.stoermer.xxx.domain.Werkzeug;
+
+public class BeglueckungSchablone extends Schablone {
+
+	private Integer level;
+	private String text;
+	private Integer sekundenVon;
+	private Integer sekundenBis;
+
+	private List<Werkzeug> benoetigteWerkzeugeBegluecktePerson;
+	private List<Werkzeug> benoetigteWerkzeugeBeglueckendePerson;
+	
+	public BeglueckungSchablone(List<Toy> benoetigteToys) {
+		super(benoetigteToys);
+		this.benoetigteWerkzeugeBeglueckendePerson = new ArrayList<>();
+		this.benoetigteWerkzeugeBegluecktePerson = new ArrayList<>();
+	}
+
+	public boolean isAusfuehrbar(Spieler begluecktePerson, Spieler beglueckendePerson, int currentLevel) {
+		if (currentLevel != level  && (currentLevel - 1) != level) {
+			return false;
+		}
+		for (Werkzeug werkzeug : benoetigteWerkzeugeBegluecktePerson) {
+			if (!begluecktePerson.istVerfuegbar(werkzeug)) {
+				return false;
+			}
+		}
+		if (benoetigteWerkzeugeBeglueckendePerson.isEmpty()) {
+			return true;
+		} else {			
+			for (Werkzeug werkzeug : benoetigteWerkzeugeBeglueckendePerson) {
+				if (beglueckendePerson.istVerfuegbar(werkzeug)) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+	
+	public Beglueckung beglueckungAusSchablone(Spieler begluecktePerson, Spieler beglueckendePerson) {
+		Integer timerSekunden = null;
+		if (sekundenVon != null) {
+			if (sekundenBis != null) {
+				timerSekunden = new Random().nextInt(sekundenVon, sekundenBis);
+			} else {
+				timerSekunden = sekundenVon;
+			}
+		}
+		return new Beglueckung(begluecktePerson, beglueckendePerson, text, timerSekunden);
+	}
+	
+	public static BeglueckungSchablone fromXml(de.stoermer.xxx.domain.xml.Beglueckung xml, List<de.stoermer.xxx.domain.xml.Toy> alle) {
+		List<Toy> benoetigt = getBenoetigteToys(alle, xml.getBenoetigteToyIds());		
+		BeglueckungSchablone schablone = new BeglueckungSchablone(benoetigt);
+		schablone.level = xml.getLevel() == null ? 1 : xml.getLevel();
+		schablone.text = xml.getText();
+		schablone.sekundenVon = xml.getSekundenVon();
+		schablone.sekundenBis = xml.getSekundenBis();
+		if (xml.getBenoetigteBegluecktePerson() != null) {
+			xml.getBenoetigteBegluecktePerson().forEach(werkzeug -> schablone.benoetigteWerkzeugeBegluecktePerson.add(Werkzeug.valueOf(werkzeug)));
+		}
+		if (xml.getBenoetigteBeglueckendePerson() != null) {			
+			xml.getBenoetigteBeglueckendePerson().forEach(werkzeug -> schablone.benoetigteWerkzeugeBeglueckendePerson.add(Werkzeug.valueOf(werkzeug)));
+		}
+		return schablone;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/Bestrafung.java

@@ -0,0 +1,21 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public class Bestrafung extends ZeitgesteuerteAufgabe {
+
+	public Bestrafung(Spieler spieler1, Spieler spieler2, String text, Integer timerSekunden) {
+		super(spieler1, spieler2, text, timerSekunden);
+	}
+
+	@Override
+	public void ok() {
+		
+	}
+
+	@Override
+	public void abbrechen() {
+		
+	}
+
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/BestrafungSchablone.java

@@ -0,0 +1,76 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import de.stoermer.xxx.domain.Spieler;
+import de.stoermer.xxx.domain.Toy;
+import de.stoermer.xxx.domain.Werkzeug;
+import de.stoermer.xxx.domain.xml.Strafe;
+
+public class BestrafungSchablone extends Schablone {
+
+	private Integer level;
+	private String text;
+	private Integer sekundenVon;
+	private Integer sekundenBis;
+	
+	private List<Werkzeug> benoetigteWerkzeugeBestraftePerson;
+	private List<Werkzeug> benoetigteWerkzeugeBestrafendePerson;
+	
+	public BestrafungSchablone(List<Toy> benoetigteToys) {
+		super(benoetigteToys);
+		benoetigteWerkzeugeBestraftePerson = new ArrayList<>();
+		benoetigteWerkzeugeBestrafendePerson = new ArrayList<>();
+	}
+
+	public boolean isAusfuehrbar(Spieler bestraftePerson, Spieler bestrafendePerson, Integer currentLevel) {
+		if (currentLevel != level && (currentLevel - 1) != level) {
+			return false;
+		}
+		for (Werkzeug werkzeug : benoetigteWerkzeugeBestraftePerson) {
+			if (!bestraftePerson.istVerfuegbar(werkzeug)) {
+				return false;
+			}
+		}
+		if (benoetigteWerkzeugeBestrafendePerson.isEmpty()) {
+			return true;
+		} else {			
+			for (Werkzeug werkzeug : benoetigteWerkzeugeBestrafendePerson) {
+				if (bestrafendePerson.istVerfuegbar(werkzeug)) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+	
+	public Bestrafung neueBestrafung(Spieler spieler1, Spieler spieler2) {
+		Integer timerSekunden = null;
+		if (sekundenVon != null) {
+			if (sekundenBis != null) {
+				timerSekunden = new Random().nextInt(sekundenVon, sekundenBis);
+			} else {
+				timerSekunden = sekundenVon;
+			}
+		}
+		return new Bestrafung(spieler1, spieler2, text, timerSekunden);
+	}
+	
+	public static BestrafungSchablone fromXml(Strafe xml, List<de.stoermer.xxx.domain.xml.Toy> alle) {
+		List<Toy> benoetigt = getBenoetigteToys(alle, xml.getBenoetigteToyIds());		
+		BestrafungSchablone schablone = new BestrafungSchablone(benoetigt);
+		schablone.level = xml.getLevel() == null ? 1 : xml.getLevel();
+		schablone.text = xml.getText();
+		schablone.sekundenVon = xml.getSekundenVon();
+		schablone.sekundenBis = xml.getSekundenBis();
+		if (xml.getBenoetigtBestraftePerson() != null) {
+			xml.getBenoetigtBestraftePerson().forEach(werkzeug -> schablone.benoetigteWerkzeugeBestraftePerson.add(Werkzeug.valueOf(werkzeug)));
+		}
+		if (xml.getBenoetigtBestrafendePerson() != null) {			
+			xml.getBenoetigtBestrafendePerson().forEach(werkzeug -> schablone.benoetigteWerkzeugeBestrafendePerson.add(Werkzeug.valueOf(werkzeug)));
+		}
+		return schablone;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/Lock.java

@@ -0,0 +1,60 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.time.LocalDateTime;
+
+import de.stoermer.xxx.domain.Spieler;
+import de.stoermer.xxx.domain.Werkzeug;
+
+public class Lock extends Aufgabe {
+	
+	private final int minuten;
+	private LocalDateTime releaseTime;
+
+	private final String releaseText;
+	private final Werkzeug werkzeug;
+	
+	public Lock(Spieler spieler1, Spieler spieler2, String text, int minuten, Werkzeug werkzeug, String releaseText) {
+		super(spieler1, spieler2, text);
+		this.minuten = minuten;
+		this.werkzeug = werkzeug;
+		this.releaseText = releaseText;
+	}
+	
+	public void verlaengern(int times) {
+		releaseTime.plusMinutes((times * minuten));
+	}
+	
+	@Override
+	public Timer getTimer() {
+		return null;
+	}
+	@Override
+	public void ok() {
+		releaseTime = LocalDateTime.now().plusMinutes(minuten);
+		getSpieler1().lock(this);		
+	}
+	@Override
+	public void abbrechen() {
+	}
+
+	public String getReleaseText() {
+		return releaseText.replace("$SPIELER1", getSpieler1().getName()).replace("$SPIELER2", getSpieler2().getName());
+	}
+
+	public Werkzeug getWerkzeug() {
+		return werkzeug;
+	}
+
+	public LocalDateTime getReleaseTime() {
+		return releaseTime;
+	}
+	
+	public int getMinuten() {
+		return minuten;
+	}
+	
+	@Override
+	public String toString() {
+		return "Lock " + werkzeug + " bis " + releaseTime + " (" + minuten + ")";
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/LockSchablone.java

@@ -0,0 +1,54 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.List;
+import java.util.Random;
+
+import de.stoermer.xxx.domain.Spieler;
+import de.stoermer.xxx.domain.Toy;
+import de.stoermer.xxx.domain.Werkzeug;
+import de.stoermer.xxx.domain.xml.Sperre;
+
+public class LockSchablone extends Schablone  {
+
+	private static final int INTERVAL_STD = 15;
+	private String text;
+	private String releaseText;
+	private Werkzeug werkzeug;
+	private Integer minutenVon;
+	private Integer minutenBis;
+	
+	public LockSchablone(List<Toy> benoetigteToys) {
+		super(benoetigteToys);
+	}
+	
+	public Werkzeug getWerkzeug() {
+		return werkzeug;
+	}
+	
+	public Lock neuesLock(Spieler weggesperrterSpieler, Spieler keyholder) {
+		return new Lock(weggesperrterSpieler, keyholder, text, getInterval(minutenVon, minutenBis), werkzeug, releaseText);
+	}
+
+	private int getInterval(Integer minutenVon, Integer minutenBis) {
+		if (minutenVon == null) {
+			return INTERVAL_STD;
+		} else if (minutenBis == null) {
+			return minutenVon;
+		} else {
+			return new Random().nextInt(minutenVon, minutenBis);
+		}
+	}
+	
+	public static LockSchablone fromXml(Sperre xml, List<de.stoermer.xxx.domain.xml.Toy> alle) {
+		List<Toy> benoetigt = getBenoetigteToys(alle, xml.getBenoetigteToyIds());	
+		LockSchablone schablone = new LockSchablone(benoetigt);
+		schablone.text = xml.getText();
+		schablone.releaseText = xml.getReleaseText();
+		
+		schablone.minutenVon = xml.getMinutenVon();
+		schablone.minutenBis = xml.getMinutenBis();
+		schablone.werkzeug = Werkzeug.valueOf(xml.getVerschluss());
+		
+		return schablone;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/RumMachen.java

@@ -0,0 +1,28 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.Random;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public class RumMachen extends Aufgabe {
+
+	private static final String TEXT = "Ups, da ist etwas schief gelaufen. Keine Potentielle Aufgabe gefunden. $SPIELER1 und $SPIELER2 überbücken die Zeit mit leidenschaftlichen Küssen.";
+	
+	public RumMachen(Spieler spieler1, Spieler spieler2) {
+		super(spieler1, spieler2, TEXT);
+	}
+
+	@Override
+	public Timer getTimer() {
+		return new Timer(new Random().nextInt(60, 180));
+	}
+
+	@Override
+	public void ok() {
+	}
+
+	@Override
+	public void abbrechen() {
+	}
+
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/Schablone.java

@@ -0,0 +1,27 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.stoermer.xxx.domain.Toy;
+
+public class Schablone {
+
+	private final List<Toy> benoetigteToys;
+	
+	public Schablone(List<Toy> benoetigteToys) {
+		this.benoetigteToys = benoetigteToys;
+	}
+	
+	public boolean moeglich(List<Toy> verfuegbareToys) {
+		return benoetigteToys.stream().allMatch(toy -> verfuegbareToys.contains(toy));
+	}
+	
+	protected static List<Toy> getBenoetigteToys(List<de.stoermer.xxx.domain.xml.Toy> alle, List<String> benoetigteToyIds) {
+		List<Toy> benoetigt = new ArrayList<>();
+		if (benoetigteToyIds != null) {
+			benoetigteToyIds.forEach(id -> benoetigt.add(Toy.fromXml(alle.stream().filter(toy -> toy.getId().equals(id)).findFirst().get())));
+		}
+		return benoetigt;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/Timer.java

@@ -0,0 +1,22 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+
+public class Timer {
+
+	private int sekunden;
+	private LocalDateTime ziel;
+	
+	public Timer(int sekunden) {
+		this.sekunden = sekunden;
+	}
+	
+	public void start() {
+		ziel = LocalDateTime.now().plusSeconds(sekunden);
+	}
+	
+	public int getRestSekunden() {
+		return (int) ChronoUnit.SECONDS.between(LocalDateTime.now(), ziel);
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/UltimativeStrafe.java

@@ -0,0 +1,28 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import java.util.Random;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public class UltimativeStrafe extends Aufgabe {
+
+	private static final String TEXT = "$SPIELER2, verschnüre $SPIELER1 fachmännisch inkl. KG, Plugs, Knebel, Aufgabebinde und was dir sonst einfällt. Nutze die Ruhe für was auch immer du möchtest.";
+	
+	public UltimativeStrafe(Spieler spieler1, Spieler spieler2) {
+		super(spieler1, spieler2, TEXT);
+	}
+
+	@Override
+	public Timer getTimer() {
+		return new Timer(new Random().nextInt(1800, 7200));		
+	}
+
+	@Override
+	public void ok() {
+	}
+
+	@Override
+	public void abbrechen() {
+	}
+
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/aufgaben/ZeitgesteuerteAufgabe.java

@@ -0,0 +1,18 @@
+package de.stoermer.xxx.domain.aufgaben;
+
+import de.stoermer.xxx.domain.Spieler;
+
+public abstract class ZeitgesteuerteAufgabe extends Aufgabe {
+
+	private Integer timerSekunden;
+
+	public ZeitgesteuerteAufgabe(Spieler spieler1, Spieler spieler2, String text, Integer timerSekunden) {
+		super(spieler1, spieler2, text);
+		this.timerSekunden = timerSekunden;
+	}
+
+	@Override
+	public Timer getTimer() {		
+		return timerSekunden == null ? null : new Timer(timerSekunden);
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/xml/Beglueckung.java

@@ -0,0 +1,72 @@
+package de.stoermer.xxx.domain.xml;
+
+import java.util.List;
+
+public class Beglueckung {
+
+	private Integer level;
+	private String text;
+	private Integer sekundenVon;
+	private Integer sekundenBis;
+
+	private List<String> benoetigteBegluecktePerson;
+	private List<String> benoetigteBeglueckendePerson;
+	
+	private List<String> benoetigteToyIds;
+	
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public Integer getSekundenVon() {
+		return sekundenVon;
+	}
+
+	public void setSekundenVon(Integer sekundenVon) {
+		this.sekundenVon = sekundenVon;
+	}
+
+	public Integer getSekundenBis() {
+		return sekundenBis;
+	}
+
+	public void setSekundenBis(Integer sekundenBis) {
+		this.sekundenBis = sekundenBis;
+	}
+
+	public List<String> getBenoetigteBegluecktePerson() {
+		return benoetigteBegluecktePerson;
+	}
+
+	public void setBenoetigteBegluecktePerson(List<String> benoetigteBegluecktePerson) {
+		this.benoetigteBegluecktePerson = benoetigteBegluecktePerson;
+	}
+
+	public List<String> getBenoetigteBeglueckendePerson() {
+		return benoetigteBeglueckendePerson;
+	}
+
+	public void setBenoetigteBeglueckendePerson(List<String> benoetigteBeglueckendePerson) {
+		this.benoetigteBeglueckendePerson = benoetigteBeglueckendePerson;
+	}
+
+	public List<String> getBenoetigteToyIds() {
+		return benoetigteToyIds;
+	}
+
+	public void setBenoetigteToyIds(List<String> benoetigteToyIds) {
+		this.benoetigteToyIds = benoetigteToyIds;
+	}
+
+	public Integer getLevel() {
+		return level;
+	}
+
+	public void setLevel(Integer level) {
+		this.level = level;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/xml/Sperre.java

@@ -0,0 +1,63 @@
+package de.stoermer.xxx.domain.xml;
+
+import java.util.List;
+
+public class Sperre {
+
+	private String text;
+	private String releaseText;
+	private String verschluss;
+
+	private Integer minutenVon;
+	private Integer minutenBis;
+	
+	private List<String> benoetigteToyIds;
+	
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public String getReleaseText() {
+		return releaseText;
+	}
+
+	public void setReleaseText(String releaseText) {
+		this.releaseText = releaseText;
+	}
+
+	public String getVerschluss() {
+		return verschluss;
+	}
+
+	public void setVerschluss(String verschluss) {
+		this.verschluss = verschluss;
+	}
+
+	public Integer getMinutenVon() {
+		return minutenVon;
+	}
+
+	public void setMinutenVon(Integer minutenVon) {
+		this.minutenVon = minutenVon;
+	}
+
+	public Integer getMinutenBis() {
+		return minutenBis;
+	}
+
+	public void setMinutenBis(Integer minutenBis) {
+		this.minutenBis = minutenBis;
+	}
+
+	public List<String> getBenoetigteToyIds() {
+		return benoetigteToyIds;
+	}
+
+	public void setBenoetigteToyIds(List<String> benoetigteToyIds) {
+		this.benoetigteToyIds = benoetigteToyIds;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/xml/StandardAufgaben.java

@@ -0,0 +1,46 @@
+package de.stoermer.xxx.domain.xml;
+
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement
+public class StandardAufgaben {
+
+	private List<Toy> toys;
+	private List<Sperre> sperren;
+	private List<Strafe> strafen;
+	private List<Beglueckung> beglueckungen;
+
+	public List<Sperre> getSperren() {
+		return sperren;
+	}
+
+	public void setSperren(List<Sperre> sperren) {
+		this.sperren = sperren;
+	}
+
+	public List<Strafe> getStrafen() {
+		return strafen;
+	}
+
+	public void setStrafen(List<Strafe> strafen) {
+		this.strafen = strafen;
+	}
+
+	public List<Beglueckung> getBeglueckungen() {
+		return beglueckungen;
+	}
+
+	public void setBeglueckungen(List<Beglueckung> beglueckungen) {
+		this.beglueckungen = beglueckungen;
+	}
+
+	public List<Toy> getToys() {
+		return toys;
+	}
+
+	public void setToys(List<Toy> toys) {
+		this.toys = toys;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/xml/Strafe.java

@@ -0,0 +1,73 @@
+package de.stoermer.xxx.domain.xml;
+
+import java.util.List;
+
+public class Strafe {
+
+	private Integer level;
+	private String text;
+	private Integer sekundenVon;
+	private Integer sekundenBis;
+
+	private List<String> benoetigtBestraftePerson;
+	private List<String> benoetigtBestrafendePerson;
+
+	private List<String> benoetigteToyIds;
+	
+	public String getText() {
+		return text;
+	}
+
+	public void setText(String text) {
+		this.text = text;
+	}
+
+	public Integer getSekundenVon() {
+		return sekundenVon;
+	}
+
+	public void setSekundenVon(Integer sekundenVon) {
+		this.sekundenVon = sekundenVon;
+	}
+
+	public Integer getSekundenBis() {
+		return sekundenBis;
+	}
+
+	public void setSekundenBis(Integer sekundenBis) {
+		this.sekundenBis = sekundenBis;
+	}
+
+	public List<String> getBenoetigtBestraftePerson() {
+		return benoetigtBestraftePerson;
+	}
+
+	public void setBenoetigtBestraftePerson(List<String> benoetigtBestraftePerson) {
+		this.benoetigtBestraftePerson = benoetigtBestraftePerson;
+	}
+
+	public List<String> getBenoetigtBestrafendePerson() {
+		return benoetigtBestrafendePerson;
+	}
+
+	public void setBenoetigtBestrafendePerson(List<String> benoetigtBestrafendePerson) {
+		this.benoetigtBestrafendePerson = benoetigtBestrafendePerson;
+	}
+
+	public List<String> getBenoetigteToyIds() {
+		return benoetigteToyIds;
+	}
+
+	public void setBenoetigteToyIds(List<String> benoetigteToyIds) {
+		this.benoetigteToyIds = benoetigteToyIds;
+	}
+
+	public Integer getLevel() {
+		return level;
+	}
+
+	public void setLevel(Integer level) {
+		this.level = level;
+	}
+
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/xml/Toy.java

@@ -0,0 +1,30 @@
+package de.stoermer.xxx.domain.xml;
+
+public class Toy {
+
+	private String id;
+	private String name;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+	
+	static Toy from(String id, String name) {
+		Toy toy = new Toy();
+		toy.id = id;
+		toy.name = name;
+		return toy;
+	}
+}

xxx-domain/src/main/java/de/stoermer/xxx/domain/xml/XmlAufgabenProvider.java

@@ -0,0 +1,78 @@
+package de.stoermer.xxx.domain.xml;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+
+import de.stoermer.xxx.domain.SchablonenProvider;
+import de.stoermer.xxx.domain.Toy;
+import de.stoermer.xxx.domain.aufgaben.BeglueckungSchablone;
+import de.stoermer.xxx.domain.aufgaben.BestrafungSchablone;
+import de.stoermer.xxx.domain.aufgaben.LockSchablone;
+
+public class XmlAufgabenProvider implements SchablonenProvider {
+
+	private List<de.stoermer.xxx.domain.Toy> toys = new ArrayList<>();
+	private List<LockSchablone> sperren = new ArrayList<>();
+	private List<BeglueckungSchablone> beglueckungen = new ArrayList<>();
+	private List<BestrafungSchablone> bestrafungen = new ArrayList<>();
+
+	public void initSchablonen() {
+		try {			
+			Unmarshaller unmarshaller = JAXBContext.newInstance(StandardAufgaben.class).createUnmarshaller();
+			StandardAufgaben aufgaben = (StandardAufgaben) unmarshaller
+					.unmarshal(getClass().getResourceAsStream("std.xml"));
+			aufgaben.getToys().forEach(xml -> this.toys.add(Toy.fromXml(xml)));
+			aufgaben.getBeglueckungen()
+			.forEach(xml -> beglueckungen.add(BeglueckungSchablone.fromXml(xml, aufgaben.getToys())));
+			aufgaben.getSperren().forEach(xml -> sperren.add(LockSchablone.fromXml(xml, aufgaben.getToys())));
+			aufgaben.getStrafen().forEach(xml -> bestrafungen.add(BestrafungSchablone.fromXml(xml, aufgaben.getToys())));
+		} catch (JAXBException exception) {
+			exception.printStackTrace();
+		}
+	}
+	
+	void safe(StandardAufgaben aufgaben) throws JAXBException, URISyntaxException {
+		URL resourceUrl = getClass().getResource("std.xml");
+		File file = new File(resourceUrl.toURI());
+		StringWriter writer = new StringWriter();
+		JAXBContext.newInstance(StandardAufgaben.class).createMarshaller().marshal(aufgaben, writer);
+		try (FileOutputStream fos = new FileOutputStream(file)) {
+			fos.write(writer.toString().getBytes());
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	public List<LockSchablone> getSperren() {
+		return sperren;
+	}
+
+	@Override
+	public List<BeglueckungSchablone> getBeglueckungen() {
+		return beglueckungen;
+	}
+
+	@Override
+	public List<BestrafungSchablone> getStrafen() {
+		return bestrafungen;
+	}
+	
+	@Override
+	public List<de.stoermer.xxx.domain.Toy> getToys() {
+		return toys;
+	}
+}

xxx-domain/src/main/testdaten/de/stoermer/xxx/domain/xml/AufgabenCreator.java

@@ -0,0 +1,282 @@
+package de.stoermer.xxx.domain.xml;
+
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import javax.xml.bind.JAXBException;
+
+import de.stoermer.xxx.domain.Werkzeug;
+
+public class AufgabenCreator {
+
+	private Toy vibrator = Toy.from("vibr_1", "Vibrator");
+	private Toy dildoKlein = Toy.from("dildo_klein", "Dildo klein");
+	private Toy dildoMittel= Toy.from("dildo_mittel", "Dildo mittel");
+	private Toy dildoGross = Toy.from("dildo_gross", "Dildo groß");
+	private Toy plugKlein = Toy.from("plug_klein", "Plug klein");
+	private Toy plugGross = Toy.from("plug_gross", "Plug groß");
+	private Toy eletroPlug = Toy.from("electro_plug", "Electro Plug");
+	private Toy fesseln = Toy.from("fesseln", "Fesseln");
+	private Toy augenbinde = Toy.from("augenbinde", "Augenbinde");
+	private Toy ballknebel = Toy.from("ball_knebel", "Ballknebel");
+	private Toy penisknebel = Toy.from("penis_knebel", "Penisknebel");
+	private Toy doppenPenisknebel = Toy.from("doppel_penis_knebel", "Doppel-Penisknebel");
+	private Toy pumpPlug = Toy.from("pump_plug", "Pump plug");
+	private Toy nippelklemmen = Toy.from("nippelklemmen", "Nippelklemmen");
+	private Toy fickmaschine = Toy.from("fickmaschine", "Fickmaschine");
+	private Toy penisVibrator = Toy.from("penisvibrator", "Penisvibrator");
+	private Toy peitsche = Toy.from("peitsche", "Peitsche");
+	private Toy gerte = Toy.from("gerte", "Gerte");
+	private Toy paddel = Toy.from("paddel", "Paddel");
+	private Toy kgFrau = Toy.from("kg", "Keuschheitsgürtel Frau");
+	private Toy kgMann = Toy.from("kg", "Keuschheitsgürtel Mann");
+	private Toy peniskaefig = Toy.from("peniskaefig", "Peniskäfig");
+	private Toy analVibrator = Toy.from("analvibrator", "Anal-Vibrator");
+	private Toy doppelDildo = Toy.from("doppeldildo", "Doppeldildo");
+	
+	private void init() throws JAXBException, URISyntaxException {
+		StandardAufgaben aufgaben = new StandardAufgaben();
+		aufgaben.setToys(getToys());
+		aufgaben.setBeglueckungen(getBeglueckungen());
+		aufgaben.setSperren(getSperren());
+		aufgaben.setStrafen(getStrafen());
+		
+		new XmlAufgabenProvider().safe(aufgaben);
+	}
+	
+	private List<Toy> getToys() {
+		List<Toy> toys = new ArrayList<>();
+		
+		toys.add(vibrator);
+		toys.add(dildoKlein);
+		toys.add(dildoMittel);
+		toys.add(dildoGross);
+		toys.add(plugKlein);
+		toys.add(plugGross);
+		toys.add(eletroPlug);
+		toys.add(fesseln);
+		toys.add(augenbinde);
+		toys.add(ballknebel);
+		toys.add(penisknebel);
+		toys.add(doppenPenisknebel);
+		toys.add(pumpPlug);
+		toys.add(nippelklemmen);
+		toys.add(fickmaschine);
+		toys.add(penisVibrator);
+		toys.add(peitsche);
+		toys.add(gerte);
+		toys.add(paddel);
+		toys.add(kgFrau);
+		toys.add(kgMann);
+		toys.add(peniskaefig);
+		toys.add(analVibrator);
+		toys.add(doppelDildo);
+		
+		return toys;
+	}
+
+	private List<Strafe> getStrafen() {
+		List<Strafe> result = new ArrayList<>();
+		result.add(createStrafe(1, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der flachen Hand auf das Gesäß", null, null, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		result.add(createStrafe(3, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 15 beherzte Schläge mit der flachen Hand auf das Gesäß, $SPIELER1 zählt laut mit", null, null, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		result.add(createStrafe(2, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der Gerte auf das Gesäß", null, null, Collections.emptyList(), Collections.emptyList(), Arrays.asList(gerte)));
+		result.add(createStrafe(4, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 15 beherzte Schläge Schläge mit der Gerte auf das Gesäß, $SPIELER1 zählt laut mit", null, null, Collections.emptyList(), Collections.emptyList(), Arrays.asList(gerte)));
+		result.add(createStrafe(2, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 5 Schläge mit dem Paddel auf das Gesäß", null, null, Collections.emptyList(), Collections.emptyList(), Arrays.asList(paddel)));
+		result.add(createStrafe(2, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 15 beherzte Schläge mit dem Paddel auf das Gesäß, $SPIELER1 zählt laut mit", null, null, Collections.emptyList(), Collections.emptyList(), Arrays.asList(paddel)));
+		result.add(createStrafe(3, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der Peitsche auf das Gesäß", null, null, Collections.emptyList(), Collections.emptyList(), Arrays.asList(peitsche)));
+		result.add(createStrafe(5, "$SPIELER1 stellt sich mit dem Gesicht zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 15 beherzte Schläge mit der Peitsche auf das Gesäß, $SPIELER1 zählt laut mit", null, null, Collections.emptyList(), Collections.emptyList(), Arrays.asList(peitsche)));
+		
+		result.add(createStrafe(5, "$SPIELER1 liegt auf dem Rücken mit breiten Beinen, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der Peitsche auf die Klitoris, $SPIELER1 zählt laut mit", null, null, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(peitsche)));
+		result.add(createStrafe(5, "$SPIELER1 liegt auf dem Rücken mit breiten Beinen, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der Paddel auf die Klitoris, $SPIELER1 zählt laut mit", null, null, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(paddel)));
+		result.add(createStrafe(5, "$SPIELER1 liegt auf dem Rücken mit breiten Beinen, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der Gerte auf die Klitoris, $SPIELER1 zählt laut mit", null, null, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(gerte)));
+		result.add(createStrafe(4, "$SPIELER1 liegt auf dem Rücken mit breiten Beinen, $SPIELER2 verpasst $SPIELER1 5 Schläge mit der Hand auf die Klitoris, $SPIELER1 zählt laut mit", null, null, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(peitsche)));
+		
+		result.add(createStrafe(5, "$SPIELER1 stellt sich mit dem Rücken zur Wand, Hände hinterm Kopf, Beine schulterbreit, $SPIELER2 verpasst $SPIELER1 5 Ohrfeigen, $SPIELER1 zählt laut mit", null, null, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		
+		result.add(createStrafe(5, "$SPIELER2 führt $SPIELER1 anal einen Elektro-Plug ein. $SPIELER2 erhöht ganz langsam die Intensität bis $SPIELER1 'STOP' sagt, dann fängt $SPIELER2 wieder bei null an", 30, 90, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(eletroPlug)));
+		result.add(createStrafe(4, "$SPIELER2 führt $SPIELER1 anal einen Pump-Plug ein. $SPIELER2 pumpt ganz langsam auf bis $SPIELER1 'STOP' sagt, dann fängt $SPIELER2 wieder bei null an", 30, 90, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(pumpPlug)));
+		result.add(createStrafe(4, "$SPIELER2 führt $SPIELER1 vaginal einen Elektro-Plug ein. $SPIELER2 erhöht ganz langsam die Intensität bis $SPIELER1 'STOP' sagt, dann fängt $SPIELER2 wieder bei null an", 30, 90, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(eletroPlug)));
+		result.add(createStrafe(5, "$SPIELER1 liegt auf dem Rücken, $SPIELER2 legt $SPIELER1 einen Doppel-Penisknebel an und reitet diesen vaginal oder anal", 60, 120, Arrays.asList(Werkzeug.MUND), Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(penisknebel)));
+		result.add(createStrafe(4, "$SPIELER1 liegt mit auf den Rücken gefesselten Händen auf dem Rücken, $SPIELER2 setzt sich auf das Gesicht von $SPIELER1 und lässt sich den Vaginal und/oder Analbereich verwöhnen", 90, 180, Collections.emptyList(), Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(fesseln)));
+		result.add(createStrafe(3, "$SPIELER2 legt $SPIELER1 Nippelklemmen an, $SPIELER2 zieht an der Kette und erhöht ganz langsam die Intensität bis $SPIELER1 'STOP' sagt, dann fängt $SPIELER2 wieder bei null an", 30, 90, Collections.emptyList(), Collections.emptyList(), Arrays.asList(nippelklemmen)));
+		result.add(createStrafe(5, "$SPIELER2 fesselt, knebelt und verbindet die Augen von $SPIELER1. $SPIELER2 lässt $SPIELER1 wehrlos liegen, bei Ablauf der Zeit erlöst $SPIELER2 $SPIELER1 mit einem beherzten Plapps auf den Po", 120, 180, Collections.emptyList(), Collections.emptyList(), Arrays.asList(fesseln, ballknebel, augenbinde)));
+		result.add(createStrafe(4, "$SPIELER2 fesselt und knebelt $SPIELER1. $SPIELER1 trägt dabei einen Umschnalldildo. $SPIELER2 reitet den Umschnalldildo von $SPIELER1", 60, 180, Arrays.asList(Werkzeug.UMSCHNALLDILDO), Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(fesseln, ballknebel)));
+		result.add(createStrafe(5, "$SPIELER2 fesselt und knebelt $SPIELER1. $SPIELER1 trägt dabei einen Umschnalldildo, KG und einen großen Buttplug. $SPIELER2 gibt dem Umschnalldildo einen Blowjow in 69er Positition und präsentiert $SPIELER1 dabei den Intimbereich", 
+				180, 300, Arrays.asList(Werkzeug.UMSCHNALLDILDO), Arrays.asList(Werkzeug.VAGINA), Arrays.asList(fesseln, ballknebel, kgMann, plugGross)));		
+		result.add(createStrafe(5, "$SPIELER2 knebelt $SPIELER1 und fesselt $SPIELER1 an einen Stuhl. $SPIELER1 trägt dabei einen KG und einen großen Buttplug. $SPIELER2 befriedigt sich dann vor den Augen von $SPIELER1 selber", 
+				240, 360, Collections.emptyList(), Arrays.asList(Werkzeug.VAGINA), Arrays.asList(fesseln, ballknebel, kgMann, plugGross)));
+		result.add(createStrafe(5, "$SPIELER2 knebelt $SPIELER1 und fesselt $SPIELER1 an einen Stuhl. $SPIELER1 trägt dabei einen KG und einen großen Buttplug. $SPIELER2 befriedigt sich dann vor den Augen von $SPIELER1 selber", 
+				240, 360, Collections.emptyList(), Arrays.asList(Werkzeug.PENIS), Arrays.asList(fesseln, ballknebel, kgFrau, plugGross)));
+		result.add(createStrafe(5, "$SPIELER2, zwinge $SPIELER1 vor dir auf die Knie, führe dein Glied (oder Strap on) in den Mund von $SPIELER1 ein und zeig mit einem Deepthroat, wer das sagen hat", 30, 90, Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList(), Collections.emptyList()));
+		
+		result.add(createStrafe(2, "$SPIELER2, führe langsam nach und nach mehr Finger in die Vagina von $SPIELER1 ein, bis $SPIELER1 'STOP' sagt", null, null, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Collections.emptyList()));
+		result.add(createStrafe(3, "$SPIELER2, führe langsam nach und nach mehr Finger in den Anus von $SPIELER1 ein, bis $SPIELER1 'STOP' sagt", null, null, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Collections.emptyList()));
+	
+		result.add(createStrafe(2, "$SPIELER1, geh auf die Knie und reite einen vaginal einen kleinen Dildo, befriedige dabei $SPIELER2 oral.", 60, 120, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.VAGINA), Arrays.asList(dildoKlein)));
+		result.add(createStrafe(4, "$SPIELER1, geh auf die Knie und reite einen vaginal einen großen Dildo, befriedige dabei $SPIELER2 oral.", 60, 120, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.VAGINA), Arrays.asList(dildoGross)));
+		result.add(createStrafe(2, "$SPIELER1, geh auf die Knie und reite einen anal einen kleinen Dildo, befriedige dabei $SPIELER2 oral.", 60, 120, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.VAGINA), Arrays.asList(dildoKlein)));
+		result.add(createStrafe(4, "$SPIELER1, geh auf die Knie und reite einen anal einen großen Dildo, befriedige dabei $SPIELER2 oral.", 60, 120, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.VAGINA), Arrays.asList(dildoGross)));
+
+		result.add(createStrafe(4, "$SPIELER2 dringt in Missionarsstellung in $SPIELER1 und gibt vollgas, dabei packt $SPIELER2 $SPIELER1 am Hals und drückt beherzt zu", 30, 60, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Arrays.asList(dildoGross)));
+		result.add(createStrafe(4, "$SPIELER2 dringt in Missionarsstellung anal in $SPIELER1 und gibt vollgas, dabei packt $SPIELER2 $SPIELER1 am Hals und drückt beherzt zu", 30, 60, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Arrays.asList(dildoGross)));
+
+		result.add(createStrafe(2, "$SPIELER2 nimmt die Nippel von $SPIELER1 zwischen die Finger und erhöht langsam den Druck bis $SPIELER1 'STOP' sagt", null, null, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+
+		return result ;
+	}
+
+	private Strafe createStrafe(Integer level, String text, Integer sekundenVon, Integer sekundenBis, List<Werkzeug> benoetigtBestraftePerson, List<Werkzeug> benoetigtBestrafendePerson, List<Toy> benoetigteToys) {
+		Strafe strafe = new Strafe();
+		strafe.setLevel(level);
+		strafe.setText(text);
+		strafe.setSekundenVon(sekundenVon);
+		strafe.setSekundenBis(sekundenBis);
+		strafe.setBenoetigtBestraftePerson(benoetigtBestraftePerson.stream().map(Werkzeug::toString).toList());
+		strafe.setBenoetigtBestrafendePerson(benoetigtBestrafendePerson.stream().map(Werkzeug::toString).toList());
+		strafe.setBenoetigteToyIds(benoetigteToys.stream().map(Toy::getId).toList());
+		return strafe;
+	}
+
+	private List<Sperre> getSperren() {
+		List<Sperre> result = new ArrayList<>();
+		
+		result.add(createSperre("$SPIELER1 legt sich einen KG an, $SPIELER2 spielgt Keyholder. Falls möglich sind Vaginal-Plugs zu verwenden", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem KG zu erlösen", 10, 20, Werkzeug.VAGINA, Arrays.asList(kgFrau)));
+		result.add(createSperre("$SPIELER1 legt sich einen KG an, $SPIELER2 spielgt Keyholder", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem KG zu erlösen", 10, 30, Werkzeug.VAGINA, Arrays.asList(kgFrau)));
+		result.add(createSperre("$SPIELER1 legt sich einen KG an, $SPIELER2 spielgt Keyholder", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem KG zu erlösen", 10, 30, Werkzeug.PENIS, Arrays.asList(kgMann)));
+		result.add(createSperre("$SPIELER1 legt sich einen Peniskäfig an, $SPIELER2 spielgt Keyholder", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Peniskäfig zu erlösen", 10, 30, Werkzeug.PENIS, Arrays.asList(peniskaefig)));
+		result.add(createSperre("$SPIELER2 führt $SPIELER1 einen kleinen Plug in den Anus ein, dieser ist bis auf weiteres zu tragen", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Buttplug zu erlösen", 10, 30, Werkzeug.ANUS, Arrays.asList(plugKlein)));
+		result.add(createSperre("$SPIELER2 führt $SPIELER1 einen großen Plug in den Anus ein, dieser ist bis auf weiteres zu tragen", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Buttplug zu erlösen", 10, 30, Werkzeug.ANUS, Arrays.asList(plugGross)));
+		result.add(createSperre("$SPIELER2 führt $SPIELER1 einen Elektro-Plug in den Anus ein, dieser ist bis auf weiteres zu tragen. $SPIELER2 darf $SPIELER1 !leichte Stromstöße verpassen", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Eletro-Plug zu erlösen", 5, 15, Werkzeug.ANUS, Arrays.asList(eletroPlug)));
+		result.add(createSperre("$SPIELER2 führt $SPIELER1 einen Elektro-Plug in die Vagina ein, darüber ist ein KG zu tragen. $SPIELER2 spielt Keyholder und darf $SPIELER1 !leichte Stromstöße verpassen", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Eletro-Plug und KG zu erlösen", 5, 15, Werkzeug.VAGINA, Arrays.asList(eletroPlug, kgFrau)));
+		result.add(createSperre("$SPIELER2 führt $SPIELER1 einen kleinen Dildo in die Vagina ein, darüber ist ein KG zu tragen. $SPIELER2 spielt Keyholder", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Dildo und KG zu erlösen", 10, 20, Werkzeug.VAGINA, Arrays.asList(dildoKlein, kgFrau)));
+		result.add(createSperre("$SPIELER1 trägt mit sofortiger Wirkung einen Ballknebel, $SPIELER2 achte darauf, dass er schön stramm sitzt", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Knebel zu erlösen", 5, 15, Werkzeug.MUND, Arrays.asList(ballknebel)));
+		result.add(createSperre("$SPIELER1 trägt mit sofortiger Wirkung einen Penisknebel, $SPIELER2 achte darauf, dass er schön stramm sitzt", "$SPIELER2, es ist an der Zeit $SPIELER1 von seinem Knebel zu erlösen", 5, 15, Werkzeug.MUND, Arrays.asList(penisknebel)));
+		
+		return result ;
+	}
+	
+	private Sperre createSperre(String text, String releaseText, Integer minutenVon, Integer minutenBis, Werkzeug verschluss, List<Toy> benoetigteToys) {
+		Sperre sperre = new Sperre();
+		sperre.setText(text);
+		sperre.setReleaseText(releaseText);
+		sperre.setMinutenVon(minutenVon);
+		sperre.setMinutenBis(minutenBis);
+		sperre.setBenoetigteToyIds(benoetigteToys.stream().map(Toy::getId).toList());
+		sperre.setVerschluss(verschluss.toString());
+		return sperre;
+	}
+
+	private List<Beglueckung> getBeglueckungen() {
+		List<Beglueckung> result = new ArrayList<>();
+		
+		result.add(createBeglueckung(1, "$SPIELER2, zeig $SPIELER1 deinen Hintern, gib dir selber dabei ein oder zwei Klasppse auf den Po", null, null, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, küsse den Hals von $SPIELER1 leidenschaftlich", 30, 60, Collections.emptyList(), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, zeichne mit Küssen den Bauchnabel von $SPIELER1 nach", 30, 60, Collections.emptyList(), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		
+		result.add(createBeglueckung(2, "$SPIELER2, berühre den gesamten Körper von $SPIELER1 ohne die Hände zu verwenden", 60, 120, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		
+		result.add(createBeglueckung(1, "$SPIELER1 sitzt vor $SPIELER2, $SPIELER2 küsste leidenschaftlich den Nacken von $SPIELER1", 60, 120, Arrays.asList(Werkzeug.MUND), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, Küsse die Brust von $SPIELER1 ohne die Nippel zu berühren", 60, 120, Arrays.asList(Werkzeug.MUND), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(2, "$SPIELER2, verwöhne die Nippel von $SPIELER1 mit Küssen", 60, 120, Arrays.asList(Werkzeug.MUND), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, küsse den Hintern von $SPIELER1 ohne den Anus zu berühren", 60, 120, Arrays.asList(Werkzeug.MUND), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2, verpasse $SPIELER1 eine Anusmassage mit der Zunge", 60, 120, Arrays.asList(Werkzeug.MUND), Arrays.asList(Werkzeug.ANUS), Collections.emptyList()));
+
+		result.add(createBeglueckung(2, "$SPIELER2, küsse den Intimbereich von $SPIELER1 durch die Unterwäsche", 60, 120, Arrays.asList(Werkzeug.MUND), Collections.emptyList(), Collections.emptyList()));
+		
+
+		result.add(createBeglueckung(1, "$SPIELER2, massiere die Brust von $SPIELER1 leidenschaftlich", 60, 120, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, massiere den Hintern von $SPIELER1 leidenschaftlich", 60, 120, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, massiere den Rücken von $SPIELER1 leidenschaftlich", 60, 120, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(1, "$SPIELER2, massiere die Oberschenkel von $SPIELER1 leidenschaftlich", 60, 120, Collections.emptyList(), Collections.emptyList(), Collections.emptyList()));
+		
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Klitoris von $SPIELER1 mit einem Vibrator" , 30, 180, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(vibrator)));
+		result.add(createBeglueckung(4, "$SPIELER2, verwöhne die Klitoris von $SPIELER1 mit einem Vibrator, führe dabei einen Finger in den Anus von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(vibrator)));
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Klitoris von $SPIELER1 mit dem Mund, führe dabei einen bis zwei Finger in die Vagina von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Klitoris von $SPIELER1 mit dem Mund, führe dabei einen Finger in den Anus von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2, verwöhne die Klitoris von $SPIELER1 mit der Hand, führe dabei einen bis zwei Finger in die Vagina von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Klitoris von $SPIELER1 mit der Hand, führe dabei einen Finger in den Anus von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Collections.emptyList(), Collections.emptyList()));
+		
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Eichel von $SPIELER1 mit einem Vibrator" , 30, 180, Arrays.asList(Werkzeug.PENIS), Collections.emptyList(), Arrays.asList(vibrator)));
+		result.add(createBeglueckung(4, "$SPIELER2, verwöhne die Eichel von $SPIELER1 mit einem Vibrator, führe dabei einen Finger in den Anus von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.PENIS, Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(vibrator)));
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Eichel von $SPIELER1 mit dem Mund" , 30, 180, Arrays.asList(Werkzeug.PENIS), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2, verwöhne die Eichel von $SPIELER1 mit dem Mund, führe dabei einen Finger in den Anus von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.PENIS, Werkzeug.ANUS), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne die Eichel von $SPIELER1 mit der Hand" , 30, 180, Arrays.asList(Werkzeug.PENIS), Collections.emptyList(), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2, verwöhne die Eichel von $SPIELER1 mit der Hand, führe dabei einen Finger in den Anus von $SPIELER1 ein" , 30, 180, Arrays.asList(Werkzeug.PENIS, Werkzeug.ANUS), Collections.emptyList(), Collections.emptyList()));
+		
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne den Anus von $SPIELER1 mit einem Vibrator" , 30, 180, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(vibrator)));
+		result.add(createBeglueckung(3, "$SPIELER2, verwöhne den Anus von $SPIELER1 mit dem Mund" , 30, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		
+		result.add(createBeglueckung(4, "$SPIELER2 liegt auf dem Rücken, $SPIELER1 sitzt auf seinem Gesicht. $SPIELER2, verwöhne die Vagina von $SPIELER1 mit dem Mund" , 60, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 liegt auf dem Rücken, $SPIELER1 sitzt auf seinem Gesicht. $SPIELER2, verwöhne den Anus von $SPIELER1 mit dem Mund" , 60, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+
+		result.add(createBeglueckung(4, "69er-Zeit: $SPIELER2 liegt unten. $SPIELER1, falls du verschlossen bist, zeihe einen Strap on an, damit $SPIELER2 auch was zu tun hat.", 60, 180, Arrays.asList(Werkzeug.VAGINA, Werkzeug.MUND), Arrays.asList(Werkzeug.MUND), Collections.emptyList()));
+		
+		result.add(createBeglueckung(4, "$SPIELER2, führe $SPIELER1 einen Analvibrator ein und verwöhne $SPIELER1 durch langsame Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(analVibrator)));
+		result.add(createBeglueckung(3, "$SPIELER2, führe $SPIELER1 einen kleinen Dildo anal ein und verwöhne $SPIELER1 durch langsame Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(dildoKlein)));
+		result.add(createBeglueckung(4, "$SPIELER2, führe $SPIELER1 einen großen Dildo anal ein und verwöhne $SPIELER1 durch langsame Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(dildoGross)));
+		result.add(createBeglueckung(5, "$SPIELER2, führe $SPIELER1 einen großen Dildo anal ein und verwöhne $SPIELER1 durch schnelle Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(dildoGross)));
+		
+		result.add(createBeglueckung(3, "$SPIELER2, führe $SPIELER1 einen kleinen Dildo vaginal ein und verwöhne $SPIELER1 durch langsame Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(dildoKlein)));
+		result.add(createBeglueckung(4, "$SPIELER2, führe $SPIELER1 einen großen Dildo vaginal ein und verwöhne $SPIELER1 durch langsame Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(dildoGross)));
+		result.add(createBeglueckung(5, "$SPIELER2, führe $SPIELER1 einen großen Dildo vaginal ein und bewege selbigen möglichst schnell rein und raus" , 30, 60, Arrays.asList(Werkzeug.VAGINA), Collections.emptyList(), Arrays.asList(dildoGross)));
+		
+		result.add(createBeglueckung(5, "$SPIELER2, führe $SPIELER1 einen Doppeldildo anal und vaginal ein und bewege selbigen möglichst schnell rein und raus" , 30, 60, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(doppelDildo)));
+		result.add(createBeglueckung(4, "$SPIELER2, führe $SPIELER1 einen Doppeldildo anal und vaginal und verwöhne $SPIELER1 durch langsame Bewegungen mit selbigem" , 30, 180, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Collections.emptyList(), Arrays.asList(doppelDildo)));
+		
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Missionarstellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen", 60, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Missionarstellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen", 30, 90, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Missionarstellung in $SPIELER1 ein und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Missionarstellung den Anus von $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen", 60, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Missionarstellung den Anus von $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen", 30, 90, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Missionarstellung den Anus von $SPIELER1 und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		
+		result.add(createBeglueckung(3, "$SPIELER1 setzt sich in Reiterstellung auf $SPIELER2. $SPIELER1 bestimmt das Tempo", 60, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER1 setzt sich in Reiterstellung auf $SPIELER2. $SPIELER1 versucht das Tempo hoch zu halten", 60, 120, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER1 setzt sich in Reiterstellung auf $SPIELER2 und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		
+		result.add(createBeglueckung(3, "$SPIELER1 setzt sich in Reiterstellung mit dem Anus auf $SPIELER2. $SPIELER1 bestimmt das Tempo", 60, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER1 setzt sich in Reiterstellung mit dem Anus auf $SPIELER2. $SPIELER1 versucht das Tempo hoch zu halten", 60, 120, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER1 setzt sich in Reiterstellung mit dem Anus auf $SPIELER2 und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen", 60, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen", 60, 120, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen. Dabei dringt $SPIELER2 mit einem oder zwei Fingern in den Po von $SPIELER1  ein", 60, 180, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen. Dabei dringt $SPIELER2 mit einem oder zwei Fingern in den Po von $SPIELER1  ein", 60, 120, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und gibt vollgas. Dabei dringt $SPIELER2 mit einem oder zwei Fingern in den Po von $SPIELER1  ein", 30, 60, Arrays.asList(Werkzeug.VAGINA, Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein und gibt vollgas. $SPIELER1 darf dabei keinen laut von sich geben.", 30, 60, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Hundestellung in $SPIELER1 ein. $SPIELER2 hält still und $SPIELER1 gibt das Tempo vor", 60, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Hundestellung den Anus von $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen", 60, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Hundestellung den Anus von $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen", 60, 120, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Hundestellung den Anus von $SPIELER1 ein und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Hundestellung den Anus von $SPIELER1 ein. $SPIELER2 hält still und $SPIELER1 gibt das Tempo vor\"", 30, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Löffelchenstellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen", 60, 180, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Löffelchenstellung in $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen", 60, 120, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Löffelchenstellung in $SPIELER1 ein und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.VAGINA), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(3, "$SPIELER2 dringt in Löffelchenstellung den Anus von $SPIELER1 ein und verwöhnt $SPIELER1 mit langsamen Bewegungen", 60, 180, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(4, "$SPIELER2 dringt in Löffelchenstellung den Anus von $SPIELER1 ein und verwöhnt $SPIELER1 mit schnellen Bewegungen", 60, 120, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		result.add(createBeglueckung(5, "$SPIELER2 dringt in Löffelchenstellung den Anus von $SPIELER1 ein und gibt vollgas", 30, 60, Arrays.asList(Werkzeug.ANUS), Arrays.asList(Werkzeug.PENIS, Werkzeug.UMSCHNALLDILDO), Collections.emptyList()));
+		
+		return result;
+	}
+	
+	private Beglueckung createBeglueckung(Integer level, String text, Integer sekundenVon, Integer sekundenBis, List<Werkzeug> benoetigtBestraftePerson, List<Werkzeug> benoetigtBestrafendePerson, List<Toy> benoetigteToys) {
+		Beglueckung beglueckung = new Beglueckung();
+		beglueckung.setLevel(level);
+		beglueckung.setText(text);
+		beglueckung.setSekundenVon(sekundenVon);
+		beglueckung.setSekundenBis(sekundenBis);
+		beglueckung.setBenoetigteBegluecktePerson(benoetigtBestraftePerson.stream().map(Werkzeug::toString).toList());
+		beglueckung.setBenoetigteBeglueckendePerson(benoetigtBestrafendePerson.stream().map(Werkzeug::toString).toList());
+		beglueckung.setBenoetigteToyIds(benoetigteToys.stream().map(Toy::getId).toList());
+		return beglueckung;
+	}
+
+	public static void main(String[] args) throws JAXBException, URISyntaxException {
+		new AufgabenCreator().init();
+	}
+}