Initialer Commit

xxx-client/.classpath

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/main/resources"/>
+	<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 combineaccessrules="false" exported="true" kind="src" path="/xxx-domain"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

xxx-client/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>xxx-client</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-client/.settings/org.eclipse.core.resources.prefs

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

xxx-client/.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-client/src/main/java/de/stoermer/xxx/client/DebugDialog.java

@@ -0,0 +1,110 @@
+package de.stoermer.xxx.client;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.Locale;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+
+import de.stoermer.xxx.domain.Session;
+import de.stoermer.xxx.domain.Spieler;
+import de.stoermer.xxx.domain.aufgaben.Lock;
+
+public class DebugDialog extends JDialog {
+	private static final long serialVersionUID = 1L;
+	private Session session;
+
+	public DebugDialog(MainFrame mainFrame, Session session) {
+		this.session = session;
+		setModal(true);
+		this.setContentPane(getJContentPane());
+		this.setPreferredSize(new Dimension(800,600));
+		pack();
+		this.setLocationRelativeTo(mainFrame);
+		setVisible(true);
+	}
+	
+	private JPanel getJContentPane() {
+		JPanel panel = new JPanel(new BorderLayout());
+		panel.add(getCenterPane(), BorderLayout.CENTER);
+		panel.add(getButtonPanel(), BorderLayout.SOUTH);
+		return panel;
+	}
+	
+	private JScrollPane getCenterPane() {
+		JPanel panel = new JPanel(new GridLayout((session.getSpieler().size() + 1), 1, 5, 5));
+		
+		JPanel sessionDetails = new JPanel(new GridLayout(6, 2, 5,5));
+		sessionDetails.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY));
+		
+		JLabel level = new JLabel("Level: " + session.getLevel());
+		JLabel aufgabenProLevel = new JLabel("Aufgaben pro Level: " + session.getAufgabenProLevel());
+		JLabel aufgabenInLevel = new JLabel("Aufgaben in Level:" + session.getAufgabeAufAktuellenLevel());
+		JLabel wahrscheinlichkeitSperre = new JLabel("Wahrscheinlichkeit Sperre: " + session.getWahrscheinlichkeitSperre());
+		JLabel wahrscheinlichkeitStrafe = new JLabel("Wahrscheinlichkeit Strafe: " + session.getWahrscheinlichkeitStrafe());
+		
+		JLabel nummerAufgaben = new JLabel("Anzahl Aufgaben: " + session.getBeglueckungen().size());
+		JLabel nummerSperren = new JLabel("Anzahl Sprerren: " + session.getSperren().size());
+		JLabel nummerStrafen = new JLabel("Anzahl Strafen: " + session.getStrafen().size());
+		
+		sessionDetails.add(level);
+		sessionDetails.add(wahrscheinlichkeitSperre);
+		sessionDetails.add(aufgabenProLevel);
+		sessionDetails.add(wahrscheinlichkeitStrafe);
+		sessionDetails.add(aufgabenInLevel);
+		sessionDetails.add(new JLabel());
+		sessionDetails.add(nummerAufgaben);
+		sessionDetails.add(new JLabel());
+		sessionDetails.add(nummerSperren);
+		sessionDetails.add(new JLabel());
+		sessionDetails.add(nummerStrafen);		
+		sessionDetails.add(new JLabel());
+		
+		panel.add(sessionDetails);
+		
+		for (Spieler spieler : session.getSpieler()) {
+			JPanel spielerPanel = new JPanel(new GridLayout((3 + spieler.getCurrentLocks().entrySet().size()), 1,5,5));
+			spielerPanel.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY));
+			
+			spielerPanel.add(new JLabel("Name: " + spieler.getName()));
+			
+			StringBuilder rollenBuilder = new StringBuilder();
+			spieler.getRollen().forEach(rolle -> rollenBuilder.append(rolle.anzeigeText() + "; "));
+			spielerPanel.add(new JLabel("Rollen: " + rollenBuilder.toString().trim()));
+			
+			StringBuilder werkzeugBuilder = new StringBuilder();
+			spieler.getWerkzeuge().forEach(werkzeug -> werkzeugBuilder.append(werkzeug.anzeigeText() + "; "));
+			spielerPanel.add(new JLabel("Tools: " + werkzeugBuilder.toString().trim()));
+			
+			for (Lock lock : spieler.getCurrentLocks().entrySet().stream().map(entry -> entry.getValue()).toList()) {
+				spielerPanel.add(new JLabel("Lock " + lock.getWerkzeug() + " bis " + lock.getReleaseTime().format(
+						DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT).withLocale(new Locale("de"))) + " (ursprünglich " + lock.getMinuten() + " Minuten)"));
+			}
+			
+			panel.add(spielerPanel);
+		}
+		
+		JScrollPane result = new JScrollPane(panel);
+		return result;
+	}
+	
+	private JPanel getButtonPanel() {
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		
+		JButton abbrechen = new JButton("Abbrechen");
+		abbrechen.addActionListener((e) -> this.dispose());
+		buttons.add(abbrechen);
+		
+		return buttons;
+	}
+}

xxx-client/src/main/java/de/stoermer/xxx/client/IngamePanel.java

@@ -0,0 +1,297 @@
+package de.stoermer.xxx.client;
+
+import java.awt.BorderLayout;
+import java.awt.FlowLayout;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.Clip;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextArea;
+
+import de.stoermer.xxx.domain.Session;
+import de.stoermer.xxx.domain.aufgaben.Aufgabe;
+import de.stoermer.xxx.domain.aufgaben.Timer;
+
+public class IngamePanel extends JPanel {
+	private static final long serialVersionUID = 1L;
+	private boolean doContinue;
+	private MainFrame mainFrame;
+	private Session session;
+	private Clip clip;
+	private JPanel northPanel;
+
+	public IngamePanel(MainFrame mainFrame, Session session) {
+		super(new BorderLayout());
+		this.mainFrame = mainFrame;
+		this.session = session;
+	}
+	
+	private JPanel getNorthPanel() {
+		if (northPanel == null) {
+			northPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+			
+			JButton hauptmenue = new JButton("Hauptmenü");
+			hauptmenue.addActionListener((e) -> mainFrame.hauptMenu());
+			northPanel.add(hauptmenue );
+			
+			JButton debug = new JButton("Debug Statistiken");
+			debug.addActionListener((e) -> new DebugDialog(mainFrame, session));
+			northPanel.add(debug);
+		}
+		return northPanel;
+	}
+	
+	public void init() {
+		naechsteAufgabe(session.naechsteAufgabe());
+	}
+	
+	private void naechsteAufgabe(Aufgabe aufgabe) {
+		if (aufgabe.getSpieler2() != null) {
+			showName(aufgabe);
+		} else {
+			showAufgabe(aufgabe);
+		}
+	}
+	
+	@Override
+	public void removeAll() {
+		super.removeAll();
+	
+		this.add(getNorthPanel(), BorderLayout.NORTH);
+	}
+	
+	private void showName(Aufgabe aufgabe) {	
+		this.removeAll();
+		
+		JPanel panel = new JPanel(new BorderLayout());
+
+		JPanel namePanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+		namePanel.add(new JLabel("<html><b>" + aufgabe.getSpieler2().getName() + ", du bist an der Reihe</b></html>"));
+		
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		JButton button = new JButton("LOS");
+		button.addActionListener((e) -> showAufgabe(aufgabe));
+		buttons.add(button);
+
+		panel.add(namePanel, BorderLayout.CENTER);
+		panel.add(buttons, BorderLayout.SOUTH);
+		
+		this.add(panel, BorderLayout.CENTER);
+		validate();
+	}
+
+	private void showAufgabe(Aufgabe aufgabe) {
+		this.removeAll();
+		JPanel panel = new JPanel(new BorderLayout());
+		JTextArea area = new JTextArea(10, 50);
+		area.setText(aufgabe.anzeigeText());
+		area.setEditable(false);
+		area.setWrapStyleWord(true);
+		area.setLineWrap(true);
+		panel.add(area, BorderLayout.CENTER);
+		
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		JButton abbrechen = new JButton("Abbrechen");
+		abbrechen.addActionListener((e) -> {
+			aufgabe.abbrechen();
+			List<String> fertigeLocks = session.pruefeLocks();
+			if (fertigeLocks != null && !fertigeLocks.isEmpty()) {
+				showFertigeLocks(fertigeLocks);
+			} else {
+				naechsteAufgabe(session.naechsteAufgabe());				
+			}
+		});
+		buttons.add(abbrechen);
+		if (aufgabe.getTimer() != null) {
+			JButton button = new JButton("LOS");
+			button.addActionListener((e) -> showTimer(aufgabe));
+			buttons.add(button);
+		} else {
+			JButton ok = new JButton("LOS");
+			ok.addActionListener((e) -> showOk(aufgabe));
+			buttons.add(ok);
+		}
+		panel.add(buttons, BorderLayout.SOUTH);
+		
+		this.add(panel, BorderLayout.CENTER);
+		validate();
+	}
+	
+	private void showOk(Aufgabe aufgabe) {
+		this.removeAll();
+		JPanel panel = new JPanel(new BorderLayout());
+		
+		JPanel textPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+		textPanel.add(new JLabel("<html><b>Alles erledigt?</b></html>"), BorderLayout.CENTER);
+		
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		JButton weiter = new JButton("Weiter");
+		weiter.addActionListener((e) -> {
+			aufgabe.ok();
+			List<String> fertigeLocks = session.pruefeLocks();
+			if (fertigeLocks != null && !fertigeLocks.isEmpty()) {
+				showFertigeLocks(fertigeLocks);
+			} else {
+				naechsteAufgabe(session.naechsteAufgabe());				
+			}
+		});
+		buttons.add(weiter);
+		
+		panel.add(textPanel, BorderLayout.CENTER);
+		panel.add(buttons, BorderLayout.SOUTH);
+		this.add(panel, BorderLayout.CENTER);
+		validate();
+	}
+	
+	private void showFertigeLocks(List<String> uebergabe) {
+		this.removeAll();
+		final List<String> fertigeLocks = new ArrayList<>(uebergabe);
+		String zuOeffnen = fertigeLocks.remove(0);
+		
+		JPanel panel = new JPanel(new BorderLayout());
+		
+		JPanel textPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+		textPanel.add(new JLabel("<html><b>" + zuOeffnen + "</b></html>"), BorderLayout.CENTER);
+		
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		JButton weiter = new JButton("Weiter");
+		weiter.addActionListener((e) -> {
+			if (fertigeLocks.isEmpty()) {
+				naechsteAufgabe(session.naechsteAufgabe());	
+			} else {
+				showFertigeLocks(fertigeLocks);
+			}
+		});
+		buttons.add(weiter);
+		
+		panel.add(textPanel, BorderLayout.CENTER);
+		panel.add(buttons, BorderLayout.SOUTH);
+		this.add(panel, BorderLayout.CENTER);
+		validate();
+		
+		
+	}
+
+	private void showTimer(Aufgabe aufgabe) {
+		this.removeAll();
+
+		doContinue = true;
+		JPanel panel = new JPanel(new BorderLayout());
+	
+		JPanel timerPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+		JLabel timerLabel = new JLabel("0:00:00");
+		timerPanel.add(timerLabel);
+		Timer timer = aufgabe.getTimer();
+		timer.start();
+		new Thread(() -> {
+			while (doContinue) {
+				int a = timer.getRestSekunden();
+			    int stunden = a / 3600;
+			    int minuten = (a % 3600) / 60;
+			    int sekunden = (a % 3600) % 60;
+			    StringBuilder timeBuilder = new StringBuilder();
+			    if (stunden > 0) {
+			    	timeBuilder.append(stunden);
+			    	if (minuten < 10) {
+			    		timeBuilder.append(":0");
+			    	} else {
+			    		timeBuilder.append(":");
+			    	}
+			    	timeBuilder.append(minuten);
+			    	if (sekunden < 10) {
+			    		timeBuilder.append(":0");
+			    	} else {
+			    		timeBuilder.append(":");
+			    	}
+			    	
+			    } else if (minuten > 0) {
+			    	timeBuilder.append(minuten);
+			    	if (sekunden < 10) {
+			    		timeBuilder.append(":0");
+			    	} else {
+			    		timeBuilder.append(":");
+			    	}
+			    }
+			    timeBuilder.append(sekunden);
+			    
+			    
+				timerLabel.setText("<html><b>" + timeBuilder.toString() + "</b></html>");
+				repaint();
+				if (timer.getRestSekunden() <= 0) {
+					doContinue = false;
+					showAlarm(aufgabe);
+				} else {
+					try {
+						Thread.sleep(100);
+					} catch (InterruptedException e1) {
+						e1.printStackTrace();
+					}
+				}
+			}
+		}).start();
+		
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		JButton abbrechen = new JButton("Abbrechen");
+		abbrechen.addActionListener((e) -> {
+			doContinue = false;
+			aufgabe.abbrechen();
+			List<String> fertigeLocks = session.pruefeLocks();
+			if (fertigeLocks != null && !fertigeLocks.isEmpty()) {
+				showFertigeLocks(fertigeLocks);
+			} else {
+				naechsteAufgabe(session.naechsteAufgabe());				
+			}
+		});
+		buttons.add(abbrechen);
+
+		panel.add(timerPanel, BorderLayout.CENTER);
+		panel.add(buttons, BorderLayout.SOUTH);
+
+		this.add(panel, BorderLayout.CENTER);
+		validate();
+	}
+	
+	private void showAlarm(Aufgabe aufgabe) {
+		this.removeAll();
+		JPanel panel = new JPanel(new BorderLayout());
+		
+		JPanel textPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+		textPanel.add(new JLabel("<html><b>Fertig!</b></html>"), BorderLayout.CENTER);
+		
+		try (AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(getClass().getResourceAsStream("Ring01.wav"))) {
+			clip = AudioSystem.getClip();
+			clip.open(audioInputStream);
+			clip.loop(Clip.LOOP_CONTINUOUSLY);
+			clip.start();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		JButton weiter = new JButton("Weiter");
+		weiter.addActionListener((e) -> {
+			if (clip != null) {
+				clip.stop();
+				clip.close();
+			}
+			aufgabe.ok();
+			List<String> fertigeLocks = session.pruefeLocks();
+			if (fertigeLocks != null && !fertigeLocks.isEmpty()) {
+				showFertigeLocks(fertigeLocks);
+			} else {
+				naechsteAufgabe(session.naechsteAufgabe());				
+			}
+		});
+		buttons.add(weiter);
+		
+		panel.add(textPanel, BorderLayout.CENTER);
+		panel.add(buttons, BorderLayout.SOUTH);
+		this.add(panel, BorderLayout.CENTER);
+		validate();
+	}
+}

xxx-client/src/main/java/de/stoermer/xxx/client/MainFrame.java

@@ -0,0 +1,47 @@
+package de.stoermer.xxx.client;
+
+import java.awt.Dimension;
+
+import javax.swing.JFrame;
+
+import de.stoermer.xxx.domain.Session;
+import de.stoermer.xxx.domain.xml.XmlAufgabenProvider;
+
+public class MainFrame extends JFrame {
+
+	private static final long serialVersionUID = 1L;
+	private XmlAufgabenProvider provider;
+
+	public MainFrame(XmlAufgabenProvider provider) {
+		this.provider = provider;
+		this.setTitle("XXX-Game");
+		this.setPreferredSize(new Dimension(800, 600));
+		StartupPanel contentPane = new StartupPanel(this, provider);
+		contentPane.init();
+		this.setContentPane(contentPane);
+		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
+		this.setVisible(true);
+		this.pack();
+		this.setLocationRelativeTo(null);
+	}
+	
+	public void hauptMenu() {
+		StartupPanel contentPane = new StartupPanel(this, provider);
+		contentPane.init();
+		this.setContentPane(contentPane);
+		revalidate();
+	}
+	
+	public void startGame(Session session) {
+		IngamePanel ingamePanel = new IngamePanel(this, session);
+		ingamePanel.init();
+		this.setContentPane(ingamePanel);
+		revalidate();
+	}
+	
+	public static void main(String[] args) {
+		XmlAufgabenProvider provider = new XmlAufgabenProvider();
+		provider.initSchablonen();
+		new MainFrame(provider);
+	}
+}

xxx-client/src/main/java/de/stoermer/xxx/client/SavedState.java

@@ -0,0 +1,19 @@
+package de.stoermer.xxx.client;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class SavedState implements Serializable {
+
+	private static final long serialVersionUID = -8787933543667040508L;
+
+	private List<SpielerBean> spieler;
+
+	public List<SpielerBean> getSpieler() {
+		return spieler;
+	}
+
+	public void setSpieler(List<SpielerBean> spieler) {
+		this.spieler = spieler;
+	}
+}

xxx-client/src/main/java/de/stoermer/xxx/client/SpielerBean.java

@@ -0,0 +1,44 @@
+package de.stoermer.xxx.client;
+
+import java.io.Serializable;
+import java.util.List;
+
+import de.stoermer.xxx.domain.Rolle;
+import de.stoermer.xxx.domain.Werkzeug;
+
+public class SpielerBean implements Serializable {
+
+	private static final long serialVersionUID = 5380248372369800954L;
+	private String name;
+	private List<Rolle> rollen;
+	private List<Werkzeug> werkzeuge;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public List<Rolle> getRollen() {
+		return rollen;
+	}
+
+	public void setRollen(List<Rolle> rollen) {
+		this.rollen = rollen;
+	}
+
+	public List<Werkzeug> getWerkzeuge() {
+		return werkzeuge;
+	}
+
+	public void setWerkzeuge(List<Werkzeug> werkzeuge) {
+		this.werkzeuge = werkzeuge;
+	}
+	
+	@Override
+	public String toString() {
+		return name;
+	}
+}

xxx-client/src/main/java/de/stoermer/xxx/client/StartupPanel.java

@@ -0,0 +1,494 @@
+package de.stoermer.xxx.client;
+
+import java.awt.BorderLayout;
+import java.awt.Button;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSlider;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.ListModel;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingUtilities;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.ListDataListener;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.text.BadLocationException;
+
+import de.stoermer.xxx.domain.Geschlecht;
+import de.stoermer.xxx.domain.InkonsistenterAufgabenZustand;
+import de.stoermer.xxx.domain.InkonsistenterSpielerZustand;
+import de.stoermer.xxx.domain.Rolle;
+import de.stoermer.xxx.domain.Session;
+import de.stoermer.xxx.domain.Spieler;
+import de.stoermer.xxx.domain.Toy;
+import de.stoermer.xxx.domain.Werkzeug;
+import de.stoermer.xxx.domain.xml.XmlAufgabenProvider;
+
+public class StartupPanel extends JPanel {
+
+	private static final long serialVersionUID = 1L;
+
+	private JTabbedPane tabbedPane;
+	
+	private JScrollPane playerPanel;
+	private JScrollPane toyPanel;
+	private JPanel einstellungenPanel;
+	
+	private JList<SpielerBean> spielerList;
+	
+	private JTextField nameField;
+	
+	private JCheckBox rolleBestrafter;
+	private JCheckBox rolleBestrafer;
+	private JCheckBox rolleBeglueckter;
+	private JCheckBox rolleBegluecker;
+	
+	private JCheckBox mund;
+	private JCheckBox vagina;
+	private JCheckBox penis;
+	private JCheckBox anus;
+	private JCheckBox umschnalldildo;
+
+	private XmlAufgabenProvider provider;
+	private Map<String, Toy> selectedToys = new HashMap<>();
+
+	private MainFrame mainFrame;
+	
+	private int valueSperren = 10;
+	private int valueStrafen = 20;
+	
+	private int gameLenght = 10;
+	
+	public StartupPanel(MainFrame mainFrame, XmlAufgabenProvider provider) {	
+		super(new BorderLayout());
+		this.mainFrame = mainFrame;
+		this.provider = provider;
+	}
+	
+	private List<SpielerBean> spieler;
+	private SpielerBean selectedSpieler;
+	
+	public void init() {
+		SavedState state = loadState();
+		if (state == null || state.getSpieler() == null || state.getSpieler().size() < 1) {		
+			this.spieler = new ArrayList<>();
+			
+			SpielerBean spieler1 = new SpielerBean();
+			spieler1.setName("Spieler 1");
+			spieler1.setRollen(new ArrayList<>(Arrays.asList(Rolle.values())));
+			spieler1.setWerkzeuge(new ArrayList<>(Arrays.asList(Werkzeug.values())));
+			spieler.add(spieler1);
+			
+			this.selectedSpieler = spieler1;
+			
+			SpielerBean spieler2 = new SpielerBean();
+			spieler2.setName("Spieler 2");
+			spieler2.setRollen(new ArrayList<>(Arrays.asList(Rolle.values())));
+			spieler2.setWerkzeuge(new ArrayList<>(Arrays.asList(Werkzeug.values())));
+			spieler.add(spieler2);
+		} else {
+			spieler = state.getSpieler();
+			this.selectedSpieler = spieler.get(0);
+		}
+		
+		tabbedPane = new JTabbedPane();
+		
+		tabbedPane.addTab("Spieler", getPlayerPanel());
+		tabbedPane.addTab("Toys", getToyPanel());
+		tabbedPane.addTab("Sonstige Einstellungen", getEinstellungenPanel());
+		
+		this.add(tabbedPane, BorderLayout.CENTER);
+		
+		provider.getToys().forEach(toy -> selectedToys.put(toy.getId(), toy));
+		
+		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+		
+		JButton start = new JButton("Start");
+		start.addActionListener((event) -> {
+			try {				
+				Session session = new Session(
+						spieler.stream().map(bean -> new Spieler(bean.getName(), Geschlecht.DIVERS, bean.getRollen(), bean.getWerkzeuge())).toList(), 
+						valueSperren, valueStrafen, selectedToys.entrySet().stream().map(entry -> entry.getValue()).toList(), gameLenght, provider);
+				safeState();
+				mainFrame.startGame(session);
+			} catch (InkonsistenterSpielerZustand | InkonsistenterAufgabenZustand exception) {
+				exception.printStackTrace();
+				JOptionPane.showMessageDialog(mainFrame, exception.getMessage(), "Fehler",
+				        JOptionPane.ERROR_MESSAGE);
+			}
+		});
+		buttonPanel.add(start);
+		this.add(buttonPanel, BorderLayout.SOUTH);
+		refreshSpieler();
+	}
+
+	private Component getEinstellungenPanel() {
+		if (einstellungenPanel == null) {
+			einstellungenPanel = new JPanel(new BorderLayout());
+			JPanel panel = new JPanel(new GridLayout(6, 1, 5, 5));
+			
+			panel.add(new JLabel("Anteil (Weg)Sperrungen"));
+			JSlider sperrenSlider = new JSlider(0, 100, 10);
+			sperrenSlider.setMinorTickSpacing(25);
+			sperrenSlider.setPaintTicks(true);
+			sperrenSlider.setPaintLabels(true);
+			sperrenSlider.setMajorTickSpacing(50);	
+			panel.add(sperrenSlider);
+			
+			panel.add(new JLabel("Anteil Strafen"));
+			JSlider strafenSlieder = new JSlider(0, 100, 20);
+			strafenSlieder.setMinorTickSpacing(25);
+			strafenSlieder.setPaintTicks(true);
+			strafenSlieder.setPaintLabels(true);
+			strafenSlieder.setMajorTickSpacing(50);	
+			panel.add(strafenSlieder);
+			
+			panel.add(new JLabel("Anteil \"normale\" Aufgaben"));
+			JSlider aufgabenSlider = new JSlider(0, 100, 60);
+			aufgabenSlider.setEnabled(false);
+			aufgabenSlider.setMinorTickSpacing(25);
+			aufgabenSlider.setPaintTicks(true);
+			aufgabenSlider.setPaintLabels(true);
+			aufgabenSlider.setMajorTickSpacing(50);	
+			panel.add(aufgabenSlider);
+			
+			panel.add(new JLabel("Spieldauer"));
+			JSlider lenghtSlieder = new JSlider(5,15);
+			lenghtSlieder.setPaintTicks(true);
+			lenghtSlieder.setPaintLabels(true);
+			lenghtSlieder.setMajorTickSpacing(10);	
+			Hashtable<Integer, JLabel> table = new Hashtable<Integer, JLabel>();
+		    table.put (5, new JLabel("kurz"));
+		    table.put (15, new JLabel("lang"));		    
+		    lenghtSlieder.setLabelTable(table);
+			panel.add(lenghtSlieder);
+			
+			sperrenSlider.addChangeListener((e) -> {
+				JSlider source = (JSlider) e.getSource();
+				if (!source.getValueIsAdjusting()) {
+					valueSperren = source.getValue();
+					if (valueSperren + valueStrafen > 100) {
+						valueStrafen = 100 - valueSperren;
+					}
+					strafenSlieder.setValue(valueStrafen);
+					aufgabenSlider.setValue(100 - valueSperren - valueStrafen);
+				}
+			});
+			strafenSlieder.addChangeListener((e) ->{
+				JSlider source = (JSlider) e.getSource();
+				if (!source.getValueIsAdjusting()) {
+					valueStrafen = source.getValue();
+					if (valueSperren + valueStrafen > 100) {
+						valueSperren = 100 - valueStrafen;
+					}
+					sperrenSlider.setValue(valueSperren);
+					aufgabenSlider.setValue(100 - valueSperren - valueStrafen);
+				}
+			});
+			lenghtSlieder.addChangeListener((e) -> {
+				JSlider source = (JSlider) e.getSource();
+				if (!source.getValueIsAdjusting()) {
+					gameLenght = source.getValue();
+				}
+			});
+			
+			einstellungenPanel.add(panel, BorderLayout.NORTH);
+		}
+		return einstellungenPanel;
+	}
+
+	private void safeState() {
+		File dir = new File(System.getProperty("user.home") + "/xxx/");
+		dir.mkdirs();
+		try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(dir.getAbsolutePath() + "/safe.dat"))) {
+			SavedState state = new SavedState();
+			state.setSpieler(spieler);
+			oos.writeObject(state);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private SavedState loadState() {
+		File file = new File(System.getProperty("user.home") + "/xxx/safe.dat");
+		if (file.exists()) {
+			try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
+				return (SavedState) ois.readObject();
+			} catch (IOException | ClassNotFoundException e) {
+				e.printStackTrace();
+			}
+		}
+		return null;
+	}
+
+	private JScrollPane getPlayerPanel() {
+		if (playerPanel == null) {
+
+			JPanel contentPane = new JPanel(new BorderLayout(10,10));
+
+			JPanel addRemovePanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
+			
+			Button add = new Button("+");
+			add.addActionListener((e)  -> {
+				if (spieler.size() < 8) {					
+					SpielerBean neuerSpieler = new SpielerBean();
+					neuerSpieler.setName("Neuer Spieler");
+					neuerSpieler.setRollen(new ArrayList<>(Arrays.asList(Rolle.values())));
+					neuerSpieler.setWerkzeuge(new ArrayList<>(Arrays.asList(Werkzeug.values())));
+					spieler.add(neuerSpieler);
+					selectedSpieler = neuerSpieler;
+					refreshSpieler();
+					repaint();
+					SwingUtilities.invokeLater(() -> spielerList.setSelectedValue(selectedSpieler, true));
+				}
+			});
+			addRemovePanel.add(add);
+			
+			Button rmv = new Button("-");
+			rmv.addActionListener((e) -> {
+				if (selectedSpieler != null && spieler.size() > 2) {
+					spieler.remove(selectedSpieler);
+					selectedSpieler = spieler.get(0);
+					spielerList.setSelectedValue(selectedSpieler, true);
+					refreshSpieler();
+					repaint();
+				}
+			});
+			addRemovePanel.add(rmv);
+			
+			contentPane.add(addRemovePanel, BorderLayout.NORTH);
+			
+			
+			spielerList = new JList<>();
+			spielerList.setPreferredSize(new Dimension(200,200));
+			spielerList.setModel(new ListModel<SpielerBean>() {
+				private List<ListDataListener> l = new ArrayList<>();
+				@Override
+				public void removeListDataListener(ListDataListener l) {
+					this.l.remove(l);
+				}
+				@Override
+				public int getSize() {
+					return spieler.size();
+				}
+				
+				@Override
+				public SpielerBean getElementAt(int index) {
+					return spieler.get(index);
+				}
+				
+				@Override
+				public void addListDataListener(ListDataListener l) {
+					this.l.add(l);
+				}
+			});
+			spielerList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+			spielerList.addListSelectionListener(new ListSelectionListener() {
+				@Override
+				public void valueChanged(ListSelectionEvent e) {
+					if (!e.getValueIsAdjusting()) {
+						selectedSpieler = spielerList.getSelectedValue();
+						refreshSpieler();
+						repaint();
+					}
+				}
+			});
+			contentPane.add(spielerList, BorderLayout.WEST);
+			
+			JPanel selectionPanel = new JPanel(new GridLayout(15, 1));
+			
+			selectionPanel.add(new JLabel("Name"));
+			
+			nameField = new JTextField();
+			nameField.setText(selectedSpieler.getName());
+			selectionPanel.add(nameField);
+			nameField.getDocument().addDocumentListener(new DocumentListener() {
+				@Override
+				public void removeUpdate(DocumentEvent e) {
+					try {
+						updateName(e.getDocument().getText(0, e.getDocument().getLength()));
+					} catch (BadLocationException e1) {
+						e1.printStackTrace();
+					}
+				}
+				
+				@Override
+				public void insertUpdate(DocumentEvent e) {
+					try {
+						updateName(e.getDocument().getText(0, e.getDocument().getLength()));
+					} catch (BadLocationException e1) {
+						e1.printStackTrace();
+					}
+				}
+				
+				@Override
+				public void changedUpdate(DocumentEvent e) {
+					try {
+						updateName(e.getDocument().getText(0, e.getDocument().getLength()));
+					} catch (BadLocationException e1) {
+						e1.printStackTrace();
+					}
+				}
+			});
+			
+			selectionPanel.add(new JLabel());
+			selectionPanel.add(new JLabel("Rollen:"));
+			
+			rolleBestrafer = new JCheckBox(Rolle.BESTRAFENDE_PERSON.anzeigeText(), true);
+			rolleBestrafer.setToolTipText(Rolle.BESTRAFENDE_PERSON.beschreibungsText());
+			rolleBestrafer.addActionListener(event -> checkRolle(Rolle.BESTRAFENDE_PERSON, rolleBestrafer.isSelected()));
+			selectionPanel.add(rolleBestrafer);
+			
+			rolleBestrafter = new JCheckBox(Rolle.BESTRAFTE_PERSON.anzeigeText(), true);
+			rolleBestrafter.setToolTipText(Rolle.BESTRAFTE_PERSON.beschreibungsText());
+			rolleBestrafter.addActionListener(event -> checkRolle(Rolle.BESTRAFTE_PERSON, rolleBestrafter.isSelected()));
+			selectionPanel.add(rolleBestrafter);
+			
+			rolleBegluecker = new JCheckBox(Rolle.BEGLUECKENDE_PERSON.anzeigeText(), true);
+			rolleBegluecker.setToolTipText(Rolle.BEGLUECKENDE_PERSON.beschreibungsText());
+			rolleBegluecker.addActionListener(event -> checkRolle(Rolle.BEGLUECKENDE_PERSON, rolleBegluecker.isSelected()));
+			selectionPanel.add(rolleBegluecker);
+			
+			rolleBeglueckter = new JCheckBox(Rolle.BEGLUECKTE_PERSON.anzeigeText(), true);
+			rolleBeglueckter.setToolTipText(Rolle.BEGLUECKTE_PERSON.beschreibungsText());
+			rolleBeglueckter.addActionListener(event -> checkRolle(Rolle.BEGLUECKTE_PERSON, rolleBeglueckter.isSelected()));
+			selectionPanel.add(rolleBeglueckter);
+			
+			selectionPanel.add(new JLabel());
+			selectionPanel.add(new JLabel("\"Werkzeuge\":"));
+			
+			mund = new JCheckBox(Werkzeug.MUND.anzeigeText(), true);
+			mund.setToolTipText(Werkzeug.MUND.beschreibungsText());
+			mund.addActionListener(evelt -> checkWerkzeug(Werkzeug.MUND, mund.isSelected()));
+			selectionPanel.add(mund);
+			
+			vagina = new JCheckBox(Werkzeug.VAGINA.anzeigeText(), true);
+			vagina.setToolTipText(Werkzeug.VAGINA.beschreibungsText());
+			vagina.addActionListener(evelt -> checkWerkzeug(Werkzeug.VAGINA, vagina.isSelected()));
+			selectionPanel.add(vagina);
+			
+			penis = new JCheckBox(Werkzeug.PENIS.anzeigeText(), true);
+			penis.setToolTipText(Werkzeug.PENIS.beschreibungsText());
+			penis.addActionListener(evelt -> checkWerkzeug(Werkzeug.PENIS, penis.isSelected()));
+			selectionPanel.add(penis);
+			
+			anus = new JCheckBox(Werkzeug.ANUS.anzeigeText(), true);
+			anus.setToolTipText(Werkzeug.ANUS.beschreibungsText());
+			anus.addActionListener(evelt -> checkWerkzeug(Werkzeug.ANUS, anus.isSelected()));
+			selectionPanel.add(anus);
+			
+			umschnalldildo = new JCheckBox(Werkzeug.UMSCHNALLDILDO.anzeigeText(), true);
+			umschnalldildo.setToolTipText(Werkzeug.UMSCHNALLDILDO.beschreibungsText());
+			umschnalldildo.addActionListener(evelt -> checkWerkzeug(Werkzeug.UMSCHNALLDILDO, umschnalldildo.isSelected()));
+			selectionPanel.add(umschnalldildo);
+			
+			contentPane.add(selectionPanel , BorderLayout.CENTER);
+
+			playerPanel = new JScrollPane(contentPane);
+		}
+		return playerPanel;
+	}
+	
+	private void updateName(String string) {
+		selectedSpieler.setName(string);
+		repaint();
+	}
+
+	private void refreshSpieler() {
+		nameField.setText(selectedSpieler.getName());
+		
+		rolleBestrafer.setSelected(selectedSpieler.getRollen().contains(Rolle.BESTRAFENDE_PERSON));
+		rolleBestrafter.setSelected(selectedSpieler.getRollen().contains(Rolle.BESTRAFTE_PERSON));
+		rolleBegluecker.setSelected(selectedSpieler.getRollen().contains(Rolle.BEGLUECKENDE_PERSON));
+		rolleBeglueckter.setSelected(selectedSpieler.getRollen().contains(Rolle.BEGLUECKTE_PERSON));
+		
+		mund.setSelected(selectedSpieler.getWerkzeuge().contains(Werkzeug.MUND));
+		vagina.setSelected(selectedSpieler.getWerkzeuge().contains(Werkzeug.VAGINA));
+		penis.setSelected(selectedSpieler.getWerkzeuge().contains(Werkzeug.PENIS));
+		anus.setSelected(selectedSpieler.getWerkzeuge().contains(Werkzeug.ANUS));
+		umschnalldildo.setSelected(selectedSpieler.getWerkzeuge().contains(Werkzeug.UMSCHNALLDILDO));
+	}
+	
+	private void checkRolle(Rolle rolle, boolean selected) {
+		if (selected) {
+			if (!selectedSpieler.getRollen().contains(rolle)) {
+				selectedSpieler.getRollen().add(rolle);
+			}
+		} else {
+			if (selectedSpieler.getRollen().contains(rolle)) {
+				selectedSpieler.getRollen().remove(rolle);
+			}
+		}
+	}
+	
+	private void checkWerkzeug(Werkzeug werkzeug, boolean selected) {
+		if (selected) {
+			if (!selectedSpieler.getWerkzeuge().contains(werkzeug)) {
+				selectedSpieler.getWerkzeuge().add(werkzeug);
+			}
+		} else {
+			if (selectedSpieler.getWerkzeuge().contains(werkzeug)) {
+				selectedSpieler.getWerkzeuge().remove(werkzeug);
+			}
+		}
+	}
+	
+	private JScrollPane getToyPanel() {
+		if (toyPanel == null) {
+
+			List<Toy> toys = provider.getToys();
+			toys.sort((toy1, toy2) -> toy1.getBeschreibung().compareTo(toy2.getBeschreibung()));
+			JPanel contentPane = new JPanel(new GridLayout(toys.size() / 2, 2));
+			
+			for (Toy toy : toys) {
+				final String id = toy.getId();
+				JCheckBox checkbox = new JCheckBox(toy.getBeschreibung(), true);
+				checkbox.setToolTipText(toy.getBeschreibung());
+				checkbox.addActionListener(event -> {
+					if (checkbox.isSelected()) {
+						Toy currentToy = toys.stream().filter(lToy -> lToy.getId().equals(id)).findFirst().get();
+						selectedToys.put(id, currentToy);
+					} else {
+						selectedToys.remove(id);
+					}
+				});
+				contentPane.add(checkbox);
+			}
+			toyPanel = new JScrollPane(contentPane);
+		}
+		return toyPanel;
+	}
+	
+	@Override
+	public void repaint() {
+		super.repaint();
+		if (spielerList != null) {			
+			spielerList.updateUI();
+		}
+	}
+}