Merge branch 'patch-1' into 'master'

Update 1.0

See merge request weicker/inb1-a-jaujau!6

.classpath

@@ -2,5 +2,6 @@
 <classpath>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1606897925456</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//src/de/jaujau/gui/Dashboard_GUI.java=UTF-8

highscore.txt

@@ -0,0 +1,15 @@
+Seb 245
+Elmo 240
+Moritz 220
+Alaa-Aldin 217
+Fabian 215
+Thomas 1233
+Emil -21331
+Heinz +312
+Gert 234
+Kasper 24
+Jens 234
+Paul 234
+Till 553
+Reiner 462
+Achim 2344

src/de/jaujau/UnitTests/TEST_Audio.java

@@ -0,0 +1,37 @@
+package de.jaujau.UnitTests;
+
+
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import de.jaujau.daten.Audio;
+
+class TEST_Audio {
+
+	Audio sound;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		sound = new Audio();
+	}
+
+	@Test
+	void test() {
+		//Test Sound in einem eigenen Thread abspielen
+		sound.spieleJau();
+		//um das Programm zu beschäftigen
+		for(int i = 0; i < 500000; i++) {
+			System.out.println(i);
+		}
+		
+		//Test Sound in einem eigenen Thread abspielen
+		sound.spieleJauJau();
+		//um das Programm zu beschäftigen
+		for(int i = 0; i < 500000; i++) {
+			System.out.println(i);
+		}
+
+	}
+
+}

src/de/jaujau/UnitTests/TEST_Kartensatz.java

@@ -0,0 +1,98 @@
+package de.jaujau.UnitTests;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import de.jaujau.daten.Farbe;
+import de.jaujau.daten.Kartensatz;
+import de.jaujau.daten.Spieler;
+
+class TEST_Kartensatz {
+
+	private Kartensatz satz;
+	
+	@BeforeEach
+	public void Setup() {
+		satz = new Kartensatz();
+		assertNotNull(satz);
+	}
+	
+	@Test
+	void ziehenSpieler() {
+		for(int i = 0; i < 31; i++) {
+			//Spieler hat zu anfang keine Karten auf der Hand
+			assertTrue(satz.getHand(Spieler.SPIELER).size()==i);
+			
+			//Karte Ziehen
+			assertTrue(satz.ziehen(Spieler.SPIELER));
+			
+			//Spieler hat eine Karte auf der Hand
+			assertTrue(satz.getHand(Spieler.SPIELER).size()==i+1);
+		}
+	}
+
+	@Test
+	void ziehenComputer() {
+		for(int i = 0; i < 31; i++) {
+			//Computer hat zu angang keine Karten auf der Hand
+			assertTrue(satz.getHand(Spieler.SPIELER).size()==i);
+			
+			//Karte Ziehen
+			assertTrue(satz.ziehen(Spieler.SPIELER));
+			
+			//Computer hat eine Karte auf der Hand
+			assertTrue(satz.getHand(Spieler.SPIELER).size()==i+1);
+		}
+	}
+	
+	@Test
+	void WunschfarbeSetzen() {
+		satz.SetWunschfarbe(Farbe.HERZ);
+		assertTrue(satz.getKarte(satz.getletzteKarte()).getFARBE()==Farbe.HERZ);
+		
+		satz.SetWunschfarbe(Farbe.KARO);
+		assertTrue(satz.getKarte(satz.getletzteKarte()).getFARBE()==Farbe.KARO);
+		
+		satz.SetWunschfarbe(Farbe.KREUZ);
+		assertTrue(satz.getKarte(satz.getletzteKarte()).getFARBE()==Farbe.KREUZ);
+		
+		satz.SetWunschfarbe(Farbe.PIK);
+		assertTrue(satz.getKarte(satz.getletzteKarte()).getFARBE()==Farbe.PIK);
+	}
+	
+	@Test
+	void legeKarte() {
+		
+		//Kein Spieler hat ein Karte
+		assertTrue(satz.getHand(Spieler.SPIELER).size()==0);
+		assertTrue(satz.getHand(Spieler.COMPUTER).size()==0);
+		
+		//Computer und Spieler Zihen jeweils eine Karte
+		assertTrue(satz.ziehen(Spieler.SPIELER));
+		assertTrue(satz.ziehen(Spieler.COMPUTER));
+		
+		//Jetzt muss jeder Spieler ein KArte auf der Hand haben
+		assertTrue(satz.getHand(Spieler.SPIELER).size()==1);
+		assertTrue(satz.getHand(Spieler.COMPUTER).size()==1);
+		
+		//KartenIndex der Spieler auslesen
+		int karteSpieler = satz.getHand(Spieler.SPIELER).get(0);
+		int karteComputer = satz.getHand(Spieler.COMPUTER).get(0);
+		
+		//Die Karten drüfen nicht gleich sein
+		assertTrue(karteSpieler != karteComputer);
+		
+		//Spieler legt Karte auf Ablagestapel
+		satz.ablegen(karteSpieler);
+		assertTrue(karteSpieler == satz.getletzteKarte());
+		assertTrue(satz.getHand(Spieler.SPIELER).size()==0);
+		
+		//Computer legt Karte auf Ablagestapel
+		satz.ablegen(karteComputer);
+		assertTrue(karteComputer == satz.getletzteKarte());
+		assertTrue(satz.getHand(Spieler.COMPUTER).size()==0);
+		
+	}
+}

src/de/jaujau/UnitTests/TEST_Texturenpaket.java

@@ -0,0 +1,49 @@
+package de.jaujau.UnitTests;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.awt.Image;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import de.jaujau.daten.Texturenpaket;
+
+class TEST_Texturenpaket {
+
+	private Texturenpaket paket;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		
+		
+	}
+
+	@Test
+	void FehlerFreiesPaketLaden() {
+		paket = new Texturenpaket("StandartTexturenBeta3.zip");
+		assertTrue(paket.ladePacket());
+		System.out.println("Name des Texturen Paketes: " + paket.getName());
+		System.out.println("Level des Texturen Paketes: " + paket.getLevel());
+	}
+	
+	@Test
+	void FehlerHaftesPaketLaden() {
+		paket = new Texturenpaket("StandartTexturenFehler");
+		assertFalse(paket.ladePacket());
+		System.out.println("Name des Fehlerhaften Texturen Paketes: " + paket.getName());
+		System.out.println("Level des Fehlerhaften Texturen Paketes: " + paket.getLevel());
+	}
+	
+	
+	@Test
+	void TexturenAusgeben() {
+		paket = new Texturenpaket("StandartTexturenBeta3.zip");
+		assertTrue(paket.ladePacket());
+		Image Bilder[] = paket.getTexturen();
+		for(int i = 0; i < 33; i++) {
+			assertTrue(Bilder[i] != null);
+		}
+	}
+	
+}

src/de/jaujau/UnitTests/TEST_TexturenpaketIntern.java

@@ -0,0 +1,33 @@
+package de.jaujau.UnitTests;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.awt.Image;
+
+import org.junit.jupiter.api.Test;
+import de.jaujau.daten.TexturenpaketIntern;
+
+class TEST_TexturenpaketIntern {
+
+	private TexturenpaketIntern paket;
+	
+	@Test
+	void FehlerFreiesPaketLaden() {
+		paket = new TexturenpaketIntern("/img/texturen/standart", "TestPaket", 0);
+		assertTrue(paket.ladePacket());
+		System.out.println("Name des Texturen Paketes: " + paket.getName());
+		System.out.println("Level des Texturen Paketes: " + paket.getLevel());
+	}
+	
+	
+	@Test
+	void TexturenAusgeben() {
+		paket = new TexturenpaketIntern("/img/texturen/standart", "TestPaket", 0);
+		assertTrue(paket.ladePacket());
+		Image Bilder[] = paket.getTexturen();
+		for(int i = 0; i < 33; i++) {
+			assertTrue(Bilder[i] != null);
+		}
+	}
+
+}

src/de/jaujau/UnitTests/TEST_Texturenpakete.java

@@ -0,0 +1,51 @@
+package de.jaujau.UnitTests;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import de.jaujau.daten.Texturenpakete;
+
+class TEST_Texturenpakete {
+
+	private Texturenpakete pakete;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		pakete = new Texturenpakete();
+	}
+
+	
+	@Test
+	void InternesPaket() {
+		assertTrue(pakete.getAnzahlPakete()==1);
+		//assertTrue(pakete.addPaket("StandartTexturenBeta3.zip"));
+		//assertTrue(pakete.getAnzahlPakete()==2);
+		assertTrue(pakete.setAktivesPaket(0));
+		assertTrue(pakete.getAktivesPaket()==0);
+		System.out.println("Test Intern");
+		System.out.println("Paket Name: " + pakete.getName(0));
+		System.out.println("Paket Level: " + pakete.getLevel(0));
+		for(int i = 0; i < 32; i++) {
+			assertTrue(pakete.getTextur(i)!=null);
+		}
+	}	
+	
+
+	@Test
+	void ExternesPaket() {
+		assertTrue(pakete.getAnzahlPakete()==1);
+		assertTrue(pakete.addPaket("StandartTexturenBeta3.zip"));
+		assertTrue(pakete.getAnzahlPakete()==2);
+		assertTrue(pakete.setAktivesPaket(1));
+		assertTrue(pakete.getAktivesPaket()==1);
+		System.out.println("Test Extern");
+		System.out.println("Paket Name: " + pakete.getName(1));
+		System.out.println("Paket Level: " + pakete.getLevel(1));
+		for(int i = 0; i < 32; i++) {
+			assertTrue(pakete.getTextur(i)!=null);
+		}
+	}
+
+}

src/de/jaujau/daten/Ablageort.java

@@ -1,5 +1,5 @@
 package de.jaujau.daten;
 
 public enum Ablageort {
-	SPIELER, COMPUTER, ABLAGESTAPEL, ZIESTAPEL
+	SPIELER, COMPUTER, ABLAGESTAPEL, ZIEHSTAPEL
 }

src/de/jaujau/daten/Audio.java

@@ -0,0 +1,97 @@
+package de.jaujau.daten;
+
+
+import java.io.IOException;
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.SourceDataLine;
+
+/**
+ * Klasse für das Abspielen eines Tons
+ * @author Sebastian Kacza
+ *
+ */
+public class Audio {
+	
+	public Audio() {}
+
+	
+	/**
+	 * Spielt den "Jau" Ton ab
+	 */
+	public void spieleJau() {
+		spieleTon("/sound/jau.wav");
+		System.out.println("AUDIO: Spiele jau.wav");
+	}
+	
+	
+	/**
+	 * Spielt den "JauJau" Ton ab
+	 */
+	public void spieleJauJau() {
+		spieleTon("/sound/jaujau.wav");
+		System.out.println("AUDIO: Spiele jaujau.wav");
+	}
+	
+	
+	/**
+	 * Spielt einen Ton ein einem eingene Thread ab
+	 * @param Pfad zu der Sounddatei im Jar-Archiv
+	 */
+	private void spieleTon(String Pfad) {
+		new Thread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					playSound(Pfad);
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		}).start();
+	}
+	
+	
+	/*
+	 * !!! DIESE METHODE IST NICHT VON MIR !!! 
+	 * Quelle: https://stackoverflow.com/questions/2416935/how-to-play-wav-files-with-java
+	 */
+	/**
+	 * Spiel eine Audio dateim im WAV-Format die im internen Ordner  gespeichert ist ab.
+	 * @param path Ptad zu der Sounddatei
+	 * @throws Exception
+	 */
+    private void playSound (String path) throws Exception {
+        //AudioInputStream audioStream = AudioSystem.getAudioInputStream(new File ("test.wav"));
+        AudioInputStream audioStream = AudioSystem.getAudioInputStream(getClass().getResourceAsStream(path));
+        
+        int BUFFER_SIZE = 128000;
+        AudioFormat audioFormat = null;
+        SourceDataLine sourceLine = null;
+
+        audioFormat = audioStream.getFormat();
+
+        sourceLine = AudioSystem.getSourceDataLine(audioFormat);
+        sourceLine.open(audioFormat);
+        sourceLine.start();
+
+        int nBytesRead = 0;
+        byte[] abData = new byte[BUFFER_SIZE];
+        while (nBytesRead != -1) {
+            try {
+                nBytesRead = 
+                audioStream.read(abData, 0, abData.length);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            if (nBytesRead >= 0) {
+                int nBytesWritten = sourceLine.write(abData, 0, nBytesRead);
+            }
+        }
+
+        sourceLine.drain();
+        sourceLine.close();
+    }
+}

src/de/jaujau/daten/Karte.java

@@ -2,11 +2,67 @@ package de.jaujau.daten;
 
 
 /**
- * Class Karte
+ * Klasse Karte
+ * Verwaltet die Daten einer Spielkarte
+ * @author Sebastian Kacza
  */
 public class Karte {
+	private final Farbe FARBE;
+	private final Wert WERT;
+	private Ablageort Ablageort;
 	
+	/**
+	 * Konstruktor für die Klasse Karte
+	 * Ablageort dird Standartmäßig auf Zielstapel gestezt
+	 * @param f Farbe der Karte
+	 * @param w	Wert der Karte
+	 */
+	public Karte(Farbe f, Wert w) {
+		FARBE = f;
+		WERT = w;
+		Ablageort = de.jaujau.daten.Ablageort.ZIEHSTAPEL;
+	}
 	
+	/**
+	 * Gibt die Farbe der Karte zurück
+	 * @return Farbe der Karte
+	 */
+	public Farbe getFARBE() {
+		return FARBE;
+	}
 	
+	/**
+	 * Gibt den Wert einer Karte zurück
+	 * @return Wert der Karte
+	 */
+	public Wert getWERT() {
+		return WERT; 
+	}
+	
+	/**
+	 * Gibt den Ablageort der Karte zurück
+	 * @return Ablageort der Karte
+	 */
+	public Ablageort getAblageort() {
+		return Ablageort;
+	}
+	
+	/**
+	 * Ändert den Ablageoert der Karte
+	 * @param ablageort Neuer Ablageort der Karte
+	 */
+	public void setAblageort(Ablageort ablageort) {
+		Ablageort = ablageort;
+	}
+
+	/**
+	 * Gibt die Eigenschaften der Karte aus Text aus
+	 * !!!Diese Methode ist nur für Debug-Ausgaben notwendig und kann Später entfernt werden!!!
+	 * @return String mit den Karten Eigenschaften
+	 */
+	@Override
+	public String toString() {
+		return "Karte [FARBE=" + FARBE + ", WERT=" + WERT + ", Ablageort=" + Ablageort + "]";
+	}
 	
 }

src/de/jaujau/daten/Kartensatz.java

@@ -1,12 +1,227 @@
 package de.jaujau.daten;
 
+import java.util.ArrayList;
+import java.util.Random;
 
 /**
- * Class Kartensatz
+ * Diese Klasse Verwaltet den Kartensatz
+ * @author Sebastian Kacza
  */
 public class Kartensatz {
+	private Karte kartensatz[];
+	private int letztekarte;
+	
+	/**
+	 * Konstruktor für den Kartensatz
+	 * Erstellt einen Neuen Kartensatz mit 32 Karten in einem Array
+	 * Die Karten haben dabei die Reihenfolge eines Standart Skat Blattes
+	 * Eine Zufällige Karte wird beim Start als Startkarte festgelet, in den Ablagestabel verschoben und als letzte Karte gespeichert
+	 */
+	public Kartensatz() {
+		
+		kartensatz = new Karte[32];
+		
+		//Standart Skat Kartensatz erstellen
+		kartensatz[0] = new Karte(Farbe.KARO, Wert.SIEBEN);
+		kartensatz[1] = new Karte(Farbe.KARO, Wert.ACHT);
+		kartensatz[2] = new Karte(Farbe.KARO, Wert.NEUN);
+		kartensatz[3] = new Karte(Farbe.KARO, Wert.ZEHN);
+		kartensatz[4] = new Karte(Farbe.KARO, Wert.BUBE);
+		kartensatz[5] = new Karte(Farbe.KARO, Wert.DAME);
+		kartensatz[6] = new Karte(Farbe.KARO, Wert.KOENING);
+		kartensatz[7] = new Karte(Farbe.KARO, Wert.ASS);
+		
+		kartensatz[8] = new Karte(Farbe.HERZ, Wert.SIEBEN);
+		kartensatz[9] = new Karte(Farbe.HERZ, Wert.ACHT);
+		kartensatz[10] = new Karte(Farbe.HERZ, Wert.NEUN);
+		kartensatz[11] = new Karte(Farbe.HERZ, Wert.ZEHN);
+		kartensatz[12] = new Karte(Farbe.HERZ, Wert.BUBE);
+		kartensatz[13] = new Karte(Farbe.HERZ, Wert.DAME);
+		kartensatz[14] = new Karte(Farbe.HERZ, Wert.KOENING);
+		kartensatz[15] = new Karte(Farbe.HERZ, Wert.ASS);
+		
+		kartensatz[16] = new Karte(Farbe.PIK, Wert.SIEBEN);
+		kartensatz[17] = new Karte(Farbe.PIK, Wert.ACHT);
+		kartensatz[18] = new Karte(Farbe.PIK, Wert.NEUN);
+		kartensatz[19] = new Karte(Farbe.PIK, Wert.ZEHN);
+		kartensatz[20] = new Karte(Farbe.PIK, Wert.BUBE);
+		kartensatz[21] = new Karte(Farbe.PIK, Wert.DAME);
+		kartensatz[22] = new Karte(Farbe.PIK, Wert.KOENING);
+		kartensatz[23] = new Karte(Farbe.PIK, Wert.ASS);
+		
+		kartensatz[24] = new Karte(Farbe.KREUZ, Wert.SIEBEN);
+		kartensatz[25] = new Karte(Farbe.KREUZ, Wert.ACHT);
+		kartensatz[26] = new Karte(Farbe.KREUZ, Wert.NEUN);
+		kartensatz[27] = new Karte(Farbe.KREUZ, Wert.ZEHN);
+		kartensatz[28] = new Karte(Farbe.KREUZ, Wert.BUBE);
+		kartensatz[29] = new Karte(Farbe.KREUZ, Wert.DAME);
+		kartensatz[30] = new Karte(Farbe.KREUZ, Wert.KOENING);
+		kartensatz[31] = new Karte(Farbe.KREUZ, Wert.ASS);
+		
+		//eine Karte als Start Karte auswählen
+		Random random = new Random();
+		letztekarte = random.nextInt(32);
+		kartensatz[letztekarte].setAblageort(Ablageort.ABLAGESTAPEL);
+	}
 	
 
+	/**
+	 * Zieht eine Zufällige karte aus dem Ziehstapel für einen bestimmten Spieler und gibt den Karten dem Spieler auf die Hand
+	 * Wenn keine Karten mehr auf dem Ziehstapel sind werden alle Karten vom Ablagestabel auf den Ziehstapel verschoben
+	 * @param spieler Spieler der die Karte auf die Hand bekommen soll
+	 */
+	public boolean ziehen(Spieler spieler) {
+		//System.out.println("Start Ziehen");
+		//Ziehstapel Prüfen
+		int ZiehstapelAnzahl = getZiehstapelAnzahl(); //ZiehstapelAnzahl könte durch direckten Medoden aufruf ersetzt werden????
+		if(ZiehstapelAnzahl < 1) { //ZiehstapelAnzahl könte durch direckten Medoden aufruf ersetzt werden????
+			//Alle Karten vom Ablagestapel ausßer letze auf den Ziehstapel verschieben
+			for(int i = 0; i < 32; i++) {
+				if((kartensatz[i].getAblageort() == Ablageort.ABLAGESTAPEL) && (i != letztekarte)) {
+					kartensatz[i].setAblageort(Ablageort.ZIEHSTAPEL);
+				}
+			}
+		}
+		
+		ZiehstapelAnzahl = getZiehstapelAnzahl(); //ZiehstapelAnzahl könte durch direckten Medoden aufruf ersetzt werden????
+		//System.out.println("ZiehStapel Anzahl " + ZiehstapelAnzahl);
+		if(ZiehstapelAnzahl > 0) {  //ZiehstapelAnzahl könte durch direckten Medoden aufruf ersetzt werden????
+			//Ziekarte bestimmen und
+			//Zienummer auswählen
+			//System.out.println("Nummer wählen");
+			Random random = new Random();
+			int auswahl = random.nextInt(ZiehstapelAnzahl); //ZiehstapelAnzahl könte durch direckten Medoden aufruf ersetzt werden????
+			//System.out.println("Karte Ziehen " + auswahl);
+			
+			//Wenn Karten auf dem Ziehspabel verfügbar sind
+			int ZiehstapelIndex = 0;
+			for(int i = 0; i < 32; i++) {
+				//System.out.println("ZielStapelIndex " + ZiehstapelIndex);
+				if(kartensatz[i].getAblageort() == Ablageort.ZIEHSTAPEL) {
+					//System.out.println("Suche " + auswahl + " ZieIndex " + ZiehstapelIndex + " KartenIndex " + i);
+					if(auswahl == ZiehstapelIndex) {
+						//System.out.println("Ziehe Karte " + i + " " + kartensatz[i].toString());
+						//Karte im Ziehstaple ist die die Ausgewählt wurde
+						if(spieler == Spieler.SPIELER) {
+							kartensatz[i].setAblageort(Ablageort.SPIELER);
+						}
+						if(spieler == Spieler.COMPUTER) {
+							kartensatz[i].setAblageort(Ablageort.COMPUTER);
+						}
+						return true;
+					}
+					ZiehstapelIndex++;	
+				}
+				
+			}
+		}
+		else {
+			System.out.println("Keine Karten zum ziehen verfügbar!");
+			return false;
+		}
+		return false;	
+	}
+	
+	
+	/**
+	 * legt die Karte mit der KartenID x auf den Ablagestapel
+	 * Speicher die KartenID der zuletzgelegt Karte in "letztekarte"
+	 * @param kartenid ID der Karte die Abgeget werden Soll
+	 */
+	public void ablegen(int kartenID) {
+		if((kartenID >= 0) && (kartenID < 32)){
+			kartensatz[kartenID].setAblageort(Ablageort.ABLAGESTAPEL);
+			letztekarte = kartenID;
+		}			
+	}
+	
+	
+	/**
+	 * gibt die ID der Kartezurück die als letztes auf dem Ablagestabel gelegt wurde
+	 * @return ID der zuletzt gelegten Karte
+	 */
+	public int getletzteKarte() {
+		return letztekarte;
+	}
+	
+
+	/**
+	 * Gibt die Karten Indexe einer Spieler Hand zuück
+	 * Wenn keine Karten auf der Hand liegen wird eine Leere ArrayList zurückgegeben
+	 * @param spieler Spieler
+	 * @return ArrayList von Integer welche die KatrenIndexe enthält, 
+	 */
+	public ArrayList<Integer> getHand(Spieler spieler) {
+		ArrayList<Integer> hand = new ArrayList<Integer>();
+		for(int i = 0; i < 32; i++) {
+			//Für Spieler
+			if(spieler == Spieler.SPIELER) {
+				if(kartensatz[i].getAblageort() == Ablageort.SPIELER) {
+					hand.add(i);
+				}
+			}
+			//Für Computer
+			if(spieler == Spieler.COMPUTER) {
+				if(kartensatz[i].getAblageort() == Ablageort.COMPUTER) {
+					hand.add(i);
+				}
+			}
+		}
+		return hand;
+	}
+	
+	
+	/**
+	 * Gibt eine Karte aus dem Kartensatz zurück
+	 * @param kartenid ID Der Karte (0 - 31)
+	 * @return Karte auf dem Kartensatz mit der ID x
+	 */
+	public Karte getKarte(int kartenID) {
+		if((kartenID >= 0) && (kartenID < 32)){
+			return kartensatz[kartenID];
+		}
+		else {
+			return null;
+		}
+		
+	}
+	
+
+	/**
+	 * Legt die Farbe fest die als nächstes auf den Ablagestapel gelegt werden muss
+	 * Dafür wird der "Wünscher" (Bube) der jeweiligen Farbe als letze Karte auf dem Ablegestabel eingetragen
+	 * @param farbe Farbe die sich gewünscht wird
+	 */
+	public void SetWunschfarbe(Farbe farbe) {
+		if(farbe == Farbe.KARO) {
+			letztekarte = 4; //Karo Bube
+		}
+		else if (farbe == Farbe.HERZ) {
+			letztekarte = 12; //Kerz Bube
+		}
+		else if (farbe == Farbe.PIK) {
+			letztekarte = 20; //Pik Bube
+		}
+		else if (farbe == Farbe.KREUZ) {
+			letztekarte = 28; //Kreuz Bube
+		}
+	}
+
+
+	/**
+	 * Dies Funktion Prüft ob sich auf dem Ziehstapel noch mindestes eine Karte Befindet
+	 * Wird nur Klassenintern Verwendet
+	 * @return true wenn keine Karten Vorhanden, false wenn kein Karte vorhanden
+	 */
+	private int getZiehstapelAnzahl() {
+		int anzahl = 0;
+		for(Karte karte: kartensatz) {
+			if(karte.getAblageort() == Ablageort.ZIEHSTAPEL) {
+				anzahl++;
+			}
+		}
+		return anzahl;
+	}
 
 
 }

src/de/jaujau/daten/Spieler.java

@@ -1,3 +1,10 @@
+/**
+
+ * @author Alaa Aldin
+
+ * @version 1.0
+
+ */
 package de.jaujau.daten;
 
 public enum Spieler {

src/de/jaujau/daten/Spielerdaten.java

@@ -1,14 +1,43 @@
+/**
+
+ * @author Alaa Aldin
+
+ * @version 1.0
+
+ */
 package de.jaujau.daten;
-
-import java.util.*;
-
+//import de.jaujau.spiellogik.Spiel;
 
 /**
  * Class Spieler
  */
+
 public class Spielerdaten {
 
+    int punktestand; // Punktestand des Spielers
+    String name /* = Spieler.getSpieler() */; // Name des Spielers
 
+    public void punktestandErhoehen(int punkt) { // Methode zum Erhoehen des Punktestandes
+        punktestand += punkt;
 
+    }
 
+    /**
+     * Get the value of punktestand
+     * 
+     * @return the value of punktestand
+     */
+
+    public int getPunktestand() {
+        return punktestand;
+    }
+
+    /**
+     * Get the value of name
+     * 
+     * @return the value of name
+     */
+    public String getName() {
+        return name;
+    }
 }

src/de/jaujau/daten/Spielerverwaltung.java

@@ -1,68 +1,67 @@
+/**
+
+ * @author Alaa Aldin
+
+ * @version 1.0
+
+ */
 package de.jaujau.daten;
 
-import java.util.*;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
 
-
-/**
- * Class Spielerverwaltung
- */
 public class Spielerverwaltung {
 
-  //
-  // Fields
-  //
-
   private int level;
-  /**
-   * arraylist von Spieler
-   */
-  private Spieler spieler;
 
-  //
-  // Constructors
-  //
-  public Spielerverwaltung () { };
+  private Spielerdaten spieler;
 
-  //
-  // Methods
-  //
-
-
-  //
-  // Accessor methods
-  //
+  private String name = "Mark Zuckerberg"; // Testeintrag
 
   /**
    * Set the value of level
-   * @param newVar the new value of level
+   * 
+   * @param newlevel the new value of level
    */
-  public void setLevel (int newVar) {
-    level = newVar;
+  public void setLevel(int newlevel) {
+    level = newlevel;
   }
 
   /**
    * Get the value of level
+   * 
    * @return the value of level
    */
-  public int getLevel () {
+  public int getLevel() {
     return level;
   }
 
   /**
-   * Set the value of spieler
-   * arraylist von Spieler
-   * @param newVar the new value of spieler
+   * Get the value of name
+   * 
+   * @return the value of name
    */
-  public void setSpieler (Spieler newVar) {
-    spieler = newVar;
+  public String getName() {
+
+    return name;
   }
 
   /**
-   * Get the value of spieler
-   * arraylist von Spieler
+   * Set the value of spieler arraylist von Spieler
+   * 
+   * @param newSpieler the new value of spieler
+   */
+  public void setSpieler(Spielerdaten newSpieler) {
+    spieler = newSpieler;
+  }
+
+  /**
+   * Get the value of spieler arraylist von Spieler
+   * 
    * @return the value of spieler
    */
-  public Spieler getSpieler () {
+  public Spielerdaten getSpieler() {
     return spieler;
   }
 
@@ -72,16 +71,62 @@ public class Spielerverwaltung {
 
   /**
    */
-  public void leseDaten()
-  {
+  public void leseDaten() {
+    throw new UnsupportedOperationException();
   }
 
-
   /**
    */
-  public void speichernDaten()
-  {
+  public void speichernDaten() {
+    throw new UnsupportedOperationException();
   }
 
+  // Die Highscore-datei wird geoeffnet und die Daten als zweidimensionales Array
+  // zurueckgegeben
+  public String[][] gethighscoreTabelle() {
+    String[][] rowData = new String[15][2];
+    BufferedReader reader;
+    try {
+      reader = new BufferedReader(new FileReader("highscore.txt"));
+      String line = reader.readLine();
+      char[] lineArray;
+      String name = "";
+      String score = "";
+      int zeilennummer = 0;
+      boolean insArray = false;
+      while (line != null) {
+        lineArray = line.toCharArray();
+        for (int i = 0; i < lineArray.length; i++) {
 
+          if (lineArray[i] != ' ' && score.length() == 0) {
+            name += lineArray[i];
+          } else if (lineArray[i] == ' ' && name.length() != 0) {
+            i++;
+            score += lineArray[i];
+
+          } else if (score.length() != 0) {
+            score += lineArray[i];
+            insArray = true;
+
+          }
+        }
+
+        if (insArray) {
+          rowData[zeilennummer][0] = name;
+          rowData[zeilennummer][1] = score;
+          insArray = false;
+        }
+
+        zeilennummer++;
+        name = score = "";
+        line = reader.readLine();
+      }
+      reader.close();
+
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    return rowData;
+  }
 }

src/de/jaujau/daten/Texturenpaket.java

@@ -0,0 +1,235 @@
+package de.jaujau.daten;
+
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Scanner;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipException;
+import java.util.zip.ZipFile;
+import javax.imageio.ImageIO;
+
+
+/*ToDo: 
+ * lesen von Datein aus Zip in eigene Methoden auslagern
+ * Fehlerprüfung nicht obtimal
+ */
+
+/**
+ * Verwaltung eines Texturenpaketes
+ * zu jedem Paket werden folgende Informationen gespeichert:
+ * Name
+ * mindes Level
+ * Pfad zu der Zip-Datei
+ * 
+ * Aufbau eines Texturenpaketes:
+ * name.zip
+ * - paket.txt
+ *   - name:NAME
+ *   - level:LEVEL als Integer
+ * - 0.png
+ * - ...
+ * - 31.png
+ * - 32.png (Rückseite)
+ * 
+ * @author Sebastian Kacza
+ *
+ */
+public class Texturenpaket {
+
+	protected String name; //Protektet weil die abgeleitet Klasse TexturenpaketIntern auf die Werte zugreifen können muss
+	protected int level;
+	private final String pfad;
+	
+	
+	/**
+	 * Erstellt ein neues Texturenpackt
+	 * @param Pfad zu der Zip-Datei des Texturenpaketes
+	 */
+	public Texturenpaket(String Pfad) {
+		name = "Nicht geladen";
+		level = 0;
+		pfad = Pfad;
+	}
+	
+	
+	/**
+	 * Läd die Packetinformationen in die lokalen Variablen und Testet das Packet auf Vollständigkeit
+	 * @return Paket vollständig geladen, true/false
+	 */
+	public boolean ladePacket() {
+		System.out.println("TEXTURENPAKET: Lade Paket");
+		if(testePaket()) {
+			//Paket ist OK
+			
+			//Paket Informationen Laden
+			
+			try {
+				File zipDatei = new File(pfad);
+				ZipFile paketDatei = new ZipFile(zipDatei);
+				ZipEntry zipInhaltPaketTXT = paketDatei.getEntry("paket.txt");
+				InputStream eingabeStromTXT = paketDatei.getInputStream(zipInhaltPaketTXT);
+				Scanner scanner = new Scanner(eingabeStromTXT);
+				while(scanner.hasNext()) {
+					String Zeile = scanner.nextLine();
+					//scanner.nextLine()
+					//scanner.next()
+					String Spalte[] = Zeile.split(":");
+					//System.out.println(Spalte.length);
+					if(Spalte.length==2) {
+						//Name Auslesen
+						if(Spalte[0].equals("name")) {
+							name = Spalte[1];
+							System.out.println("TEXTURENPAKET: Name: " + name);
+						}
+						//Level Auslesen
+						if(Spalte[0].equals("level")) {
+							level = Integer.parseInt(Spalte[1]);
+							System.out.println("TEXTURENPAKET: Level: " + level);
+						}
+						
+					}
+				}
+				scanner.close();
+				paketDatei.close();
+				
+			} catch (ZipException e) {
+				e.printStackTrace();
+				return false;
+			} catch (IOException e) {
+				e.printStackTrace();
+				return false;
+			}
+			
+		}
+		else {
+			return false;
+		}
+		return true;
+	}
+	
+	
+	/**
+	 * Gibt alle Bilddatein von dem Texturenpaket als BufferedImage Array zurück
+	 * @return BufferedImage Array der Texturen des Paketes
+	 */
+	public BufferedImage[] getTexturen() {
+		if(testePaket()) {
+			
+			try {
+				File zipDatei = new File(pfad);
+				ZipFile paketDatei = new ZipFile(zipDatei);
+				BufferedImage Bilder[] = new BufferedImage[33];
+				
+				for(int i = 0; i < 33; i++) {
+					ZipEntry zipInhaltTextur = paketDatei.getEntry(i+".png");
+					InputStream eingabeStromTextur = paketDatei.getInputStream(zipInhaltTextur);
+					Bilder[i] = ImageIO.read(eingabeStromTextur);
+				}
+				paketDatei.close();
+				return Bilder;
+				
+				
+			} catch (ZipException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+
+		}
+		return null;
+	}
+	
+	
+	/**
+	 * Gibt den Namen des Texturenpacket zurück
+	 * @return Name des Texturenpacketes
+	 */
+	public String getName() {
+		return name;
+	}
+	
+	
+	/**
+	 * Gibt den Level Wert zurück der mindestens Benötigt wird um das Packet zu benutzten
+	 * @return Mindest Level
+	 */
+	public int getLevel() {
+		return level;
+	}
+	
+	
+	/**
+	 * Testet das Texturenpaket auf vollständigkeit
+	 * @return Paket vollständig, true/false
+	 */
+	private boolean testePaket() {
+		System.out.println("TEXTURENPAKET: Paket auf Fehler untersuchen:");
+		//Testen ob Zip-Datei vorhanden und lesabar ist
+		File zipDatei = new File(pfad);
+		if(zipDatei.exists() || zipDatei.canRead()) {
+			
+			try {
+				//Zip Datei öffnen
+				ZipFile paketDatei = new ZipFile(zipDatei);
+				
+				//Paket Konfigurations Datei Prüfen
+				ZipEntry zipInhaltPaketTXT = paketDatei.getEntry("paket.txt");
+				InputStream eingabeStromTXT = paketDatei.getInputStream(zipInhaltPaketTXT);
+				Scanner scanner = new Scanner(eingabeStromTXT);
+				boolean PaketName = false;
+				boolean PaketLevel = false;
+				while(scanner.hasNext()) {
+					//Prüfen ob Konfigurations Datei die Einträge "name" und "level" enthält	
+					String Zeile = scanner.nextLine();
+					System.out.println("TEXTURENPAKET: Konfigzeile:" + Zeile);
+					if(Zeile.contains("name:")) {
+						PaketName = true;
+					}
+					if(Zeile.contains("level:")) {
+						PaketLevel = true;
+					}
+				}
+				scanner.close();
+				if(!PaketName || !PaketLevel) {
+					System.out.println("TEXTURENPAKET: Paket Konfiguration fehlerhaft");
+					paketDatei.close();
+					return false;
+				}
+				
+				//Texturen Prüfen
+				for(int i = 0; i < 33; i++) {
+					ZipEntry zipInhaltTextur = paketDatei.getEntry(i+".png");
+					InputStream eingabeStromTextur = paketDatei.getInputStream(zipInhaltTextur);
+					Image bild = ImageIO.read(eingabeStromTextur);
+					if(bild == null) {
+						System.out.println("TEXTURENPAKET: Datei: " + i + ".png nicht gefunden");
+						return false;
+					}
+					System.out.println("TEXTURENPAKET: Datei: " + i + ".png OK!");
+				}
+				
+				paketDatei.close();
+				
+			} catch (ZipException e) {
+				//Zip Datei nicht leesbar
+				e.printStackTrace();
+				return false;
+			} catch (IOException e) {
+				//Zip Datei nicht lesbar
+				e.printStackTrace();
+				return false;
+			}
+			
+		}
+		else {
+			return false;
+		}
+		
+		//Alles OK
+		System.out.println("TEXTURENPAKET: Texturen Paket ist OK");
+		return true;
+	}
+}

src/de/jaujau/daten/TexturenpaketIntern.java

@@ -0,0 +1,61 @@
+package de.jaujau.daten;
+
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+
+
+/**
+ * Klasse für Interne Texturen Pakete deren Bilddaten sich die direkt im jar Archiv befinden
+ * ein Internes Paket muss NICHT geladen werden befor es genutz werden kann!
+ * Interne Pakete werden NICHT auf vollständigkeit geprüft!
+ * @author Sebastian Kacza
+ *
+ */
+public class TexturenpaketIntern extends Texturenpaket{
+
+	public String pfad;
+	
+	
+	/**
+	 * Erstelt ein Neues Internes Texturenpaket
+	 * @param Pfad Interner Pfad du den Bilddateien z.b. /img/texturen/standart
+	 * @param Name Name des Paketes
+	 * @param Level Minideslevel des Paketes
+	 */
+	public TexturenpaketIntern(String Pfad ,String Name, int Level) {
+		super(Pfad);
+		name = Name;
+		level = Level;
+		pfad = Pfad;
+	}
+	
+	
+	/**
+	 * Das laden der Daten eines Internet Paket ist nicht notwendig!
+	 */
+	@Override
+	public boolean ladePacket() {
+		return true;
+	}
+
+	
+	/**
+	 * Gibt alle Bilddatein von dem Texturenpaket als BufferedImage Array zurück
+	 * @return BufferedImage Array der Texturen des Paketes
+	 */
+	@Override
+	public BufferedImage[] getTexturen() {
+		BufferedImage Bilder[] = new BufferedImage[33];
+		for(int i = 0; i < 33; i++) {
+			try {
+				Bilder[i] = ImageIO.read(getClass().getResource(pfad +"/" + i + ".png"));
+			} catch (IOException e) {
+				Bilder[i] = null;
+				e.printStackTrace();
+			}
+		}
+		return Bilder;
+	}	
+	
+}

src/de/jaujau/daten/Texturenpakete.java

@@ -1,12 +1,122 @@
 package de.jaujau.daten;
 
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
 
 /**
- * Class Texturenpakete
+ * Diese Klasse Verwaltet die Texturenpackete des Spiels
+ * @author Sebastian Kacza
  */
 public class Texturenpakete {
 
+	private ArrayList<Texturenpaket> TexturenpaketListe;
+	private BufferedImage Texturen[];
+	private int AktivesPaket;
 	
 	
+	public Texturenpakete(){
+		TexturenpaketListe = new ArrayList<Texturenpaket>();
+		
+		//Hinzufügen eines Internen Texturenpaketes
+		TexturenpaketListe.add(new TexturenpaketIntern("/img/texturen/standart", "JauJau Standart Texturen Französisch", 0)); 
+		
+		//Internes Texturenpaket als Aktiv festlegen
+		setAktivesPaket(0);
+	}
+	
+	
+	/**
+	 * Gibt die Anzahl der Vorhanden Texturenpakete aus
+	 * @return Anzahl Texturenpakte
+	 */
+	public int getAnzahlPakete() {
+		return TexturenpaketListe.size();
+	}
+	
+
+	/**
+	 * Gibt das min Level für ein bestimtes Paket zurück
+	 * @param PaketNummer
+	 * @return min Level
+	 */
+	public int getLevel(int PaketNr) {
+		if((PaketNr >= 0) && (PaketNr < TexturenpaketListe.size())) {
+			return TexturenpaketListe.get(PaketNr).getLevel();
+		}
+		return 0;
+	}
+	
+	
+	/**
+	 * Gibt den Namen eines Bestiment Paketes zurück
+	 * @param PaketNummer
+	 * @return Name des Paketes
+	 */
+	public String getName(int PaketNr) {
+		if((PaketNr >= 0) && (PaketNr < TexturenpaketListe.size())) {
+			return TexturenpaketListe.get(PaketNr).getName();
+		}
+		return "";
+	}
+	
+	
+	/**
+	 * Gibt die Nummer des AktivenPakes aus
+	 * @return Nummer des Aktiven Paketes
+	 */
+	public int getAktivesPaket() {
+		return AktivesPaket;
+	}
+	
+	
+	/**
+	 * Legt fest welches Texturenpaket das Aktive sein soll
+	 * Die Bilder des Aktiven Textuenpaketes werden nur Pufferung in eine Array geladen.
+	 * Dies soll Dateizugriffe beim Anzeigen der Bilder reduzieren
+	 * @param PaketNr des Paketes
+	 * @return Setzen erfolgreich true/false
+	 */
+	public boolean setAktivesPaket(int PaketNr) {
+		if((PaketNr >= 0) && (PaketNr < TexturenpaketListe.size())) {
+			AktivesPaket = PaketNr;
+			Texturen = TexturenpaketListe.get(PaketNr).getTexturen();
+			System.out.println("TEXTURENPAKETE: Paket (" + PaketNr + ") '" + TexturenpaketListe.get(PaketNr).getName() + "' aktiv gesetzt!");
+			return true;
+		}
+		return false;
+	}
+	
+	
+	/**
+	 * Es wird ein neues Texturenpaket zu der Liste hinzugefügt
+	 * Das Paket wird vor dem einfügen auf Vollständfigkeit geprüft.
+	 * Wenn es unfolständig ist wird es nicht hinzugefügt
+	 * @param Pfad zu der Texturenpaket Datei (.zip)
+	 * @return Ob das Paket erfolgreich hinzu gefügt wurde, true/false
+	 */
+	public boolean addPaket(String Pfad) {
+		Texturenpaket NeuesPaket = new Texturenpaket(Pfad);
+		if(NeuesPaket.ladePacket()) {
+			TexturenpaketListe.add(NeuesPaket);
+			System.out.println("TEXTURENPAKETE: Paket '" + NeuesPaket.getName() + "' hinzugfügt!");
+			return true;
+		}
+		
+		return false;
+	}
+
+	
+	/**
+	 * Gibt eine Textur des aktuellen Paketes als Image zurück
+	 * Wenn die ID nicht im Bereich der Karten liegt wird Kartenrückseite zurückgegebn
+	 * @param KartenNr der Textur
+	 * @return Textur als BufferedImage
+	 */
+	public BufferedImage getTextur(int KartenNr) {
+		if((KartenNr >= 0) && (KartenNr < 33)) {
+			return Texturen[KartenNr];
+		}
+		return Texturen[32];
+	}
 
 }

src/de/jaujau/gui/Dashboard_GUI.java

@@ -0,0 +1,490 @@
+package de.jaujau.gui;
+import static de.jaujau.daten.Spieler.COMPUTER;
+import static de.jaujau.daten.Spieler.SPIELER;
+
+import java.awt.BorderLayout;
+import java.awt.CardLayout;
+import java.awt.Color;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableModel;
+import de.jaujau.daten.Farbe;
+import de.jaujau.daten.Spieler;
+import de.jaujau.daten.Spielerverwaltung;
+import de.jaujau.daten.Texturenpakete;
+import de.jaujau.spiellogik.Spiel;
+import javax.swing.JLabel;
+import java.awt.Dimension;
+import java.awt.Image;
+import javax.swing.JComboBox;
+import javax.swing.SwingConstants;
+import javax.swing.ImageIcon;
+import java.awt.Rectangle;
+import java.awt.Component;
+import java.awt.FlowLayout;
+import java.awt.ComponentOrientation;
+import java.awt.Cursor;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.Font;
+import javax.swing.JButton;
+
+public class Dashboard_GUI extends JPanel{
+	private static final long serialVersionUID = -7380187913989942586L;
+	JPanel panelCont = new JPanel();
+	JPanel highscore = new JPanel();
+	JPanel game = new JPanel();
+	JPanel start = new JPanel();
+	CardLayout cl = new CardLayout();
+	Spielerverwaltung spielerverwaltung = new Spielerverwaltung();
+	private final JPanel panel = new JPanel();
+	private final JPanel panel_1 = new JPanel();
+	private JComboBox<String> comboBox = new JComboBox<String>();
+	private final JPanel panel_2 = new JPanel();
+	private final JLabel lblNewLabel_1 = new JLabel("Entwickler: Sebastian, Moritz, Fabian, Aladin, Elmar");
+	private final JPanel spielfeld = new JPanel();
+	private final JPanel player_hand = new JPanel();
+	private final JPanel gegner_hand = new JPanel();
+	JLabel ziehstapel = new JLabel("");
+	JPanel spielerkarten = new JPanel();
+	JLabel labelsspieler[] = new JLabel[32];
+	JLabel labelsgegner[] = new JLabel[32];
+	private Spiel aktuellesSpiel;
+	private JLabel label_aktuellerSpieler;
+	private Texturenpakete texturenpakete;
+	private final JPanel spielfeldmitte = new JPanel();
+	private final JPanel info_panel = new JPanel();
+	private final JPanel rechts = new JPanel();
+	private final JPanel mitte = new JPanel();
+	JLabel ablagestapel = new JLabel("");
+	JButton aussetzen = new JButton("Aussetzen");
+	JPanel mitte_unten = new JPanel();
+	JPanel mitte_center = new JPanel();
+	private JPanel mitte_oben = new JPanel();
+	private JButton btnherz = new JButton("Herz");
+	private JButton btnpik = new JButton("Pik");
+	private JButton btnkaro = new JButton("Karo");
+	private JButton btnkreuz = new JButton("Kreuz");
+	private final JLabel label_final = new JLabel("Spiel beendet");
+	private final JScrollPane gegnerkartenpane = new JScrollPane();
+	private final JPanel gegnerkarten = new JPanel();
+	
+	//Moving Image
+
+	
+	public Dashboard_GUI(Spiel Spiel, Texturenpakete texturen) {
+		setMinimumSize(new Dimension(1000, 600));
+		texturenpakete = texturen;
+		     
+	            
+		System.out.println("DASHBOARD_GUI: Aktives: " + texturenpakete.getAktivesPaket());
+		System.out.println("DASHBOARD_GUI: Anzahl: " + texturenpakete.getAnzahlPakete());
+		aktuellesSpiel = Spiel;
+		setLayout(new BorderLayout(0, 0));
+		panelCont.setLayout(cl);
+		panelCont.add(highscore, "1");
+		panelCont.add(game, "2");
+		game.setLayout(new BorderLayout(0, 0));
+		spielfeld.setBackground(new Color(128, 128, 128));
+		
+		game.add(spielfeld, BorderLayout.CENTER);
+		spielfeld.setLayout(new BorderLayout(0, 0));
+		
+		
+		
+		
+		player_hand.setPreferredSize(new Dimension(100, 240));
+		player_hand.setBackground(new Color(169, 169, 169));
+		player_hand.setLayout(new BorderLayout(0, 0));
+		spielfeld.add(player_hand, BorderLayout.SOUTH);
+
+		JScrollPane spielerkartenpane = new JScrollPane();
+		spielerkartenpane.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+		spielerkartenpane.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
+		spielerkartenpane.setPreferredSize(new Dimension(100, 240));
+		player_hand.add(spielerkartenpane, BorderLayout.CENTER);
+		
+		
+		spielerkarten.setBackground(Color.GRAY);
+		spielerkarten.setAutoscrolls(true);
+		spielerkarten.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
+		spielerkarten.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
+		spielerkartenpane.setViewportView(spielerkarten);
+		gegner_hand.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
+		
+		gegner_hand.setPreferredSize(new Dimension(10, 150));
+		gegner_hand.setBackground(Color.GRAY);
+		gegner_hand.setLayout(new BorderLayout(0, 0));
+		spielfeld.add(gegner_hand, BorderLayout.NORTH);
+		gegnerkartenpane.setPreferredSize(new Dimension(100, 140));
+		gegnerkartenpane.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
+		
+		gegner_hand.add(gegnerkartenpane, BorderLayout.CENTER);
+		gegnerkarten.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
+		gegnerkarten.setPreferredSize(new Dimension(10, 140));
+		
+		gegnerkartenpane.setViewportView(gegnerkarten);
+		
+		spielfeldmitte.setPreferredSize(new Dimension(100, 20));
+		spielfeldmitte.setLayout(new BorderLayout(0, 0));
+		JLabel beschreibung_aktuellerSpieler = new JLabel("Aktueller Spieler:");
+		beschreibung_aktuellerSpieler.setFont(new Font("Tahoma", Font.BOLD, 18));
+		beschreibung_aktuellerSpieler.setForeground(Color.BLACK);
+		info_panel.add(beschreibung_aktuellerSpieler);
+		label_aktuellerSpieler = new JLabel("Auswahlphase");
+		label_aktuellerSpieler.setForeground(Color.BLACK);
+		label_aktuellerSpieler.setFont(new Font("Tahoma", Font.BOLD, 18));
+		info_panel.add(label_aktuellerSpieler);
+				
+		spielfeld.add(spielfeldmitte, BorderLayout.CENTER);
+		spielfeldmitte.add(info_panel, BorderLayout.NORTH);
+		rechts.setPreferredSize(new Dimension(250, 10));
+		spielfeldmitte.add(rechts, BorderLayout.EAST);
+		rechts.setLayout(new BorderLayout(0, 0));
+		rechts.add(ziehstapel, BorderLayout.CENTER);
+
+		spielfeldmitte.add(mitte, BorderLayout.CENTER);
+		aussetzen.setVisible(false);
+		aussetzen.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				aussetzen.setVisible(false);
+				aktuellesSpiel.aussetzen();	
+			}
+		});
+		mitte.setLayout(new BorderLayout(0, 0));
+		mitte_unten.setPreferredSize(new Dimension(150, 50));
+		mitte_unten.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
+		btnherz.setVisible(false);
+
+		
+		mitte_unten.add(btnherz);
+		mitte_unten.add(aussetzen);
+		mitte_center.setLayout(new BorderLayout(0, 0));
+		ablagestapel.setHorizontalAlignment(SwingConstants.CENTER);
+		ablagestapel.setHorizontalTextPosition(SwingConstants.CENTER);
+		ablagestapel.setAlignmentX(Component.CENTER_ALIGNMENT);
+		
+		
+		ablagestapel.setIcon(new ImageIcon(texturenpakete.getTextur(32).getScaledInstance(150, 210, Image.SCALE_SMOOTH)));
+		mitte_center.add(ablagestapel, BorderLayout.CENTER);
+		
+		
+		mitte.add(mitte_center);
+		label_final.setVisible(false);
+		label_final.setFont(new Font("Tahoma", Font.PLAIN, 34));
+		label_final.setHorizontalAlignment(SwingConstants.CENTER);
+		label_final.setForeground(Color.BLACK);
+		
+		mitte_center.add(label_final, BorderLayout.SOUTH);
+		
+		//Wunschfarben Button Listener
+		
+		mitte.add(mitte_unten, BorderLayout.SOUTH);
+		btnpik.setVisible(false);
+		btnpik.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				aktuellesSpiel.wuenscher(Farbe.PIK);
+				showwunsch(false);
+			}
+		});
+		
+		mitte_unten.add(btnpik);
+		btnkaro.setVisible(false);
+		btnkaro.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				aktuellesSpiel.wuenscher(Farbe.KARO);
+				showwunsch(false);
+			}
+		});
+		
+		mitte_unten.add(btnkaro);
+		btnkreuz.setVisible(false);
+		btnkreuz.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				aktuellesSpiel.wuenscher(Farbe.KREUZ);
+				showwunsch(false);
+			}
+		});
+		
+		btnherz.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				aktuellesSpiel.wuenscher(Farbe.HERZ);
+				showwunsch(false);
+			}
+		});
+		
+		mitte_unten.add(btnkreuz);
+		mitte_oben.setPreferredSize(new Dimension(150, 50));
+		
+		mitte.add(mitte_oben, BorderLayout.NORTH);
+		mitte_oben.setLayout(new BorderLayout(0, 0));
+		panelCont.add(start, "3");
+		start.setLayout(new BorderLayout(0, 0));
+		panel.setPreferredSize(new Dimension(10, 30));
+		
+		start.add(panel, BorderLayout.NORTH);
+		
+		JLabel lblNewLabel = new JLabel("Spielername:");
+		panel.add(lblNewLabel);
+		comboBox.setMinimumSize(new Dimension(60, 22));
+		comboBox.setEditable(true);
+		panel.add(comboBox);
+		start.add(panel_1, BorderLayout.CENTER);
+		
+		start.add(panel_2, BorderLayout.SOUTH);
+		
+		panel_2.add(lblNewLabel_1);
+
+		highscore.setLayout(new BorderLayout(0, 0));
+		
+		//Erstes Panel wird angezeigt
+		cl.show(panelCont, "3");
+		add(panelCont);	
+		renderStart(); //Startseite beim ersten öffnen aktualisieren	
+	}
+	
+	
+	//Spiel Panel wird gezeigt
+	public void showgame(Spiel Spiel){
+		//Neues Spiel wird übergeben
+		aktuellesSpiel = Spiel;
+		System.out.println("DASHBOARD: Game darstellen");
+		cl.show(panelCont, "2");
+		showwunsch(false);
+		aussetzen.setVisible(false);
+		aktuellesSpiel.spiel(this);
+		player_hand.setVisible(true);
+		label_final.setVisible(false);
+		ablagestapel.setVisible(true);
+		rechts.setVisible(true);
+		aktualisiereGUI();
+	}
+	
+	public void showstart(){
+		System.out.println("DASHBOARD: Start darstellen");
+		cl.show(panelCont, "3");
+		renderStart();
+	}
+	
+	
+	public void showhighscore(){
+		System.out.println("DASHBOARD: Highscore darstellen");
+		renderHighscore();
+		cl.show(panelCont, "1");
+		repaint();
+		revalidate();
+	}
+	
+	
+	
+		public void renderStart(){
+			comboBox.removeAllItems();
+			for(int i = 0; i<spielerverwaltung.gethighscoreTabelle().length; i++) {
+				comboBox.addItem(spielerverwaltung.gethighscoreTabelle()[i][0]);	
+			}
+			
+		}
+	
+	// Highscore Tabelle
+		public void renderHighscore() {
+			
+			
+			
+			String[][] rowData = spielerverwaltung.gethighscoreTabelle(); //Bsp. Datensatz muss noch entfernt werden.
+
+		    String[] columnNames =  {"Name", "Punkte"};
+		    highscore.setLayout(new BorderLayout(0, 0));
+		    JTable table = new JTable(); //Leere Tabelle
+		    DefaultTableModel tableModel = new DefaultTableModel(rowData, columnNames) { //Tabelle formatieren und Zellen nicht bearbeitbar machen
+				private static final long serialVersionUID = 838285314713L;
+		        public boolean isCellEditable(int row, int column) {
+		           //all cells false
+		           return false;
+		        }
+		    };
+		    table.setAutoCreateRowSorter(true); //Tabelle Sortierbar durch Tabellenkopf
+		    table.getTableHeader().setReorderingAllowed(false); //Tabelle nicht mehr drag and drop
+		    table.setModel(tableModel);		    
+		    highscore.add( new JScrollPane( table ) );
+			
+			
+		}
+		
+		
+		//Spielerhand GUI
+		public void aktualisiereHand() {	
+			//Alle Elemente entfernen
+			for(Component c : spielerkarten.getComponents()){
+				spielerkarten.remove(c);
+				spielerkarten.revalidate();
+			}
+			
+			//Alle Karten auf der Hand darstellen
+			for(int i = 0; i< aktuellesSpiel.getKartensatz().getHand(Spieler.SPIELER).size(); i++){
+				labelsspieler[i] = new JLabel();
+				labelsspieler[i].setAlignmentY(Component.TOP_ALIGNMENT);
+				labelsspieler[i].setBounds(new Rectangle(0, 0, 120, 180));
+				labelsspieler[i].setSize(new Dimension(120, 180));
+				labelsspieler[i].setHorizontalTextPosition(SwingConstants.CENTER);
+				labelsspieler[i].setHorizontalAlignment(SwingConstants.CENTER);
+				labelsspieler[i].setName(aktuellesSpiel.getKartensatz().getHand(Spieler.SPIELER).get(i).toString());
+				
+				
+				if(btnpik.isVisible() == false) {
+				labelsspieler[i].setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+				labelsspieler[i].addMouseListener(new MouseAdapter() {
+					@Override
+					public void mouseClicked(MouseEvent e) {
+						aktuellesSpiel.karteLegen(Integer.parseInt(e.getComponent().getName()));
+						System.out.println("Karte: " + e.getComponent().getName() + " ausgewählt.");
+						aktualisiereGUI();
+					}
+				});
+				}
+				
+				labelsspieler[i].setIcon(new ImageIcon(texturenpakete.getTextur(aktuellesSpiel.getKartensatz().getHand(Spieler.SPIELER).get(i)).getScaledInstance(150, 200, Image.SCALE_SMOOTH)));
+				spielerkarten.add(labelsspieler[i]);
+				spielerkarten.updateUI(); //Panel erneuern	
+			}
+		}
+		
+		
+		
+		//Gegnerhand GUI
+		public void aktualisiereGegnerHand() {
+			
+			//Alle Elemente entfernen
+			for(Component c : gegnerkarten.getComponents()){
+				gegnerkarten.remove(c);
+				gegnerkarten.revalidate();
+			}
+			
+			//Alle Karten auf der Hand darstellen
+			for(int i = 0; i< aktuellesSpiel.getKartensatz().getHand(Spieler.COMPUTER).size(); i++){
+				labelsgegner[i] = new JLabel();
+				labelsgegner[i].setAlignmentY(Component.TOP_ALIGNMENT);
+				labelsgegner[i].setBounds(new Rectangle(0, 0, 120, 180));
+				labelsgegner[i].setSize(new Dimension(120, 180));
+				labelsgegner[i].setHorizontalTextPosition(SwingConstants.CENTER);
+				labelsgegner[i].setHorizontalAlignment(SwingConstants.CENTER);
+				labelsgegner[i].setName(aktuellesSpiel.getKartensatz().getHand(Spieler.COMPUTER).get(i).toString());
+				//Immer Rückseite anzeigen
+				labelsgegner[i].setIcon(new ImageIcon(texturenpakete.getTextur(32).getScaledInstance(90, 130, Image.SCALE_SMOOTH)));
+				gegnerkarten.add(labelsgegner[i]);
+				gegnerkarten.updateUI(); //Panel erneuern	
+			}
+		}
+		
+		
+		
+		
+		//
+		public void aktualisiereAblage(){
+			
+			//Sleep oder Wait Funktion zum Verlangsamen der Anzeige
+			
+			ablagestapel.setIcon(new ImageIcon(texturenpakete.getTextur(aktuellesSpiel.getKartensatz().getletzteKarte()).getScaledInstance(150, 210, Image.SCALE_SMOOTH)));
+			ablagestapel.revalidate();
+			ablagestapel.repaint();
+		}
+		
+		public void aktualisiereSpieleranzeige() {
+			if(aktuellesSpiel.getamZug() == Spieler.COMPUTER) {
+				label_aktuellerSpieler.setText("Gegner");			
+				label_aktuellerSpieler.setForeground(Color.RED);
+			}
+			if(aktuellesSpiel.getamZug() == Spieler.SPIELER) {
+				label_aktuellerSpieler.setText("Spieler");			
+				label_aktuellerSpieler.setForeground(Color.GREEN);
+			}
+			
+			if(aktuellesSpiel.getamZug() == null) {
+				label_aktuellerSpieler.setText("Auswahlphase");			
+				label_aktuellerSpieler.setForeground(Color.WHITE);
+			}
+	        
+		}
+		
+		public void aktualisiereZiehen() {
+			
+			for(Component c : rechts.getComponents()){
+				rechts.remove(c);
+				rechts.revalidate();
+			}
+			
+			
+			
+			System.out.println("DASHBOARD-GUI: Ziehstapel aktualisiert.");
+			
+			ziehstapel = new JLabel();
+			ziehstapel.setAlignmentX(Component.CENTER_ALIGNMENT);
+			rechts.add(ziehstapel, BorderLayout.CENTER);
+
+			ziehstapel.setPreferredSize(new Dimension(242, 362));
+			ziehstapel.setHorizontalAlignment(SwingConstants.CENTER);
+			ziehstapel.setIcon(new ImageIcon(texturenpakete.getTextur(32).getScaledInstance(150, 210, Image.SCALE_SMOOTH)));
+			
+			if(btnpik.isVisible() == false){
+			ziehstapel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+			ziehstapel.addMouseListener(new MouseAdapter() {
+				@Override
+				public void mouseClicked(MouseEvent e) {
+					aktuellesSpiel.karteZiehen();
+					aktualisiereGUI();
+				}
+			});
+			}
+		}
+		
+		
+		public void showaussetzen(boolean status) {
+			aussetzen.setVisible(status);
+			mitte_unten.updateUI();
+			//System.out.println("DASHBOARD_GUI showaussetzen bis zum Ende aufgerufen!");
+		}
+		
+		public void aktualisiereGUI(){
+			aktualisiereSpieleranzeige();
+			aktualisiereAblage();
+			aktualisiereHand();
+			aktualisiereGegnerHand();
+			aktualisiereZiehen();
+			revalidate();
+			repaint();
+		}
+		
+		public void showwunsch(boolean status){
+			btnpik.setVisible(status);
+			btnherz.setVisible(status);
+			btnkaro.setVisible(status);
+			btnkreuz.setVisible(status);
+			aktualisiereGUI();
+			mitte_unten.updateUI();
+
+		}	
+		
+		public void gewonnen(Spieler spieler) {
+			
+			if(spieler == SPIELER) {
+				System.out.println("Spiel gewonnen");
+				label_final.setText("Spiel gewonnen");
+			}
+			if(spieler == COMPUTER) {
+				System.out.println("Spieler verloren");
+				label_final.setText("Spieler verloren");
+			}
+			player_hand.setVisible(false);
+			label_final.setVisible(true);
+			ablagestapel.setVisible(false);
+			rechts.setVisible(false);
+			updateUI();
+			aktualisiereGUI();
+		}
+}
+

src/de/jaujau/gui/GUI.java

@@ -1,34 +1,203 @@
 package de.jaujau.gui;
 
-import java.util.*;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import javax.swing.JLabel;
+import javax.swing.ImageIcon;
+import javax.swing.SwingConstants;
+
+import de.jaujau.daten.Spielerverwaltung;
+import de.jaujau.daten.Texturenpakete;
+import de.jaujau.spiellogik.Spiel;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import javax.swing.BoxLayout;
+import java.awt.Font;
+
 
 
 /**
  * Class GUI
  */
-public class GUI {
+public class GUI extends JFrame{
 
   //
   // Fields
   //
-
+	private static final long serialVersionUID = 1L;
+	private boolean menuehidden = false;
+	Hilfe_GUI frame = new Hilfe_GUI();
+	private Spiel aktuellesSpiel;
   
   //
   // Constructors
   //
-  public GUI () { };
-  
-  //
-  // Methods
-  //
+  public GUI (Texturenpakete texturenpakete, Spielerverwaltung speicherung) {
+  	setMinimumSize(new Dimension(1000, 600));
 	  
 	  
-  //
-  // Accessor methods
-  //
+	// jaujau.getAktuellesSpiel();
+	  	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+  		setTitle("JauJau");
+  		setPreferredSize(new Dimension(800, 500));
+  		setSize(1565, 916);
+		getContentPane().setLayout(new BorderLayout(0, 0));
 		
-  //
-  // Other methods
-  //
+		JPanel Menue = new JPanel();
+		Menue.setPreferredSize(new Dimension(270, 450));
+		getContentPane().add(Menue, BorderLayout.WEST);
+		Menue.setLayout(new BoxLayout(Menue, BoxLayout.X_AXIS));
 		
+		JPanel MenueIcon = new JPanel();
+		MenueIcon.setPreferredSize(new Dimension(50, 450));
+		MenueIcon.setBackground(new Color(15, 19, 52));
+		Menue.add(MenueIcon);
+		MenueIcon.setLayout(null);
+		
+		JPanel help = new JPanel();
+		help.setBounds(0, 0, 50, 50);
+		help.setBackground(new Color(15, 19, 52));
+		MenueIcon.add(help);
+		
+		JLabel helplable = new JLabel("");
+		helplable.setHorizontalTextPosition(SwingConstants.CENTER);
+		helplable.setHorizontalAlignment(SwingConstants.CENTER);
+		helplable.setIcon(new ImageIcon(GUI.class.getResource("/img/help.png")));
+		help.add(helplable);
+		
+		JPanel menuebtn = new JPanel();
+		menuebtn.setBounds(0, 50, 50, 50);
+		MenueIcon.add(menuebtn);
+		menuebtn.setLayout(new BorderLayout(0, 0));
+		
+		JLabel menuelabel = new JLabel("");
+		menuelabel.setHorizontalTextPosition(SwingConstants.CENTER);
+		menuelabel.setHorizontalAlignment(SwingConstants.CENTER);
+		menuelabel.setIcon(new ImageIcon(GUI.class.getResource("/img/menue.png")));
+		menuebtn.add(menuelabel);
+		menuebtn.setBackground(new Color(15, 19, 52));
+		
+		JPanel menuhide = new JPanel();
+		menuhide.setPreferredSize(new Dimension(220, 200));
+		menuhide.setBackground(new Color(25, 29, 74));
+		Menue.add(menuhide);
+		menuhide.setLayout(null);
+		
+		JLabel startlabel = new JLabel("Startseite");
+
+		startlabel.setBounds(0, 11, 220, 29);
+		startlabel.setVerticalAlignment(SwingConstants.TOP);
+		startlabel.setForeground(Color.WHITE);
+		startlabel.setFont(new Font("Tahoma", Font.PLAIN, 24));
+		startlabel.setHorizontalAlignment(SwingConstants.CENTER);
+		menuhide.add(startlabel);
+		
+		JLabel highscorelabel = new JLabel("Highscore");
+
+		highscorelabel.setBounds(0, 51, 220, 29);
+		highscorelabel.setHorizontalAlignment(SwingConstants.CENTER);
+		highscorelabel.setForeground(Color.WHITE);
+		highscorelabel.setFont(new Font("Tahoma", Font.PLAIN, 24));
+		menuhide.add(highscorelabel);
+		
+		JLabel gamelabel = new JLabel("Spielen");
+
+		gamelabel.setHorizontalAlignment(SwingConstants.CENTER);
+		gamelabel.setForeground(Color.WHITE);
+		gamelabel.setFont(new Font("Tahoma", Font.PLAIN, 24));
+		gamelabel.setBounds(0, 91, 220, 29);
+		menuhide.add(gamelabel);
+		
+		JLabel texturenlabel = new JLabel("Texturen");
+
+		texturenlabel.setHorizontalAlignment(SwingConstants.CENTER);
+		texturenlabel.setForeground(Color.WHITE);
+		texturenlabel.setFont(new Font("Tahoma", Font.PLAIN, 24));
+		texturenlabel.setBounds(0, 131, 220, 29);
+		menuhide.add(texturenlabel);
+		
+		JPanel dashboard = new JPanel();
+		dashboard.setBackground(new Color(73, 128, 242));
+		getContentPane().add(dashboard, BorderLayout.CENTER);
+		dashboard.setLayout(new BorderLayout(0, 0));
+		
+		Dashboard_GUI Dashboard_GUI = new Dashboard_GUI(aktuellesSpiel, texturenpakete);
+		
+		//Spiel_GUI Spiel_GUI = new Spiel_GUI();
+		dashboard.add(Dashboard_GUI, BorderLayout.CENTER);
+		
+		//Event Listener
+		
+		menuebtn.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				if(menuehidden == true) {
+					menuhide.setVisible(false);
+					Menue.setPreferredSize(new Dimension(50, Menue.getHeight()));
+					menuehidden = false;
+				}else{
+					menuhide.setVisible(true);
+					Menue.setPreferredSize(new Dimension(270, Menue.getHeight()));
+					menuehidden = true;
+				}
+				
+			}
+		});
+		
+		
+		help.addMouseListener(new MouseAdapter() {
+			public void mouseClicked(MouseEvent e) {
+				if(frame.isShowing() == true) {
+					frame.setVisible(false);
+				}else{
+					frame.setVisible(true);
+				}
+				
+			}
+		});
+		
+		
+		gamelabel.addMouseListener(new MouseAdapter() {
+			public void mouseClicked(MouseEvent e) {
+				aktuellesSpiel = new Spiel(Dashboard_GUI);
+				System.out.println("GUI: Spiel GUI ge<67>ffnet");
+				Dashboard_GUI.showgame(aktuellesSpiel);
+			}
+		});
+		
+		
+		highscorelabel.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				System.out.println("GUI: Highscore ge<67>ffnet");
+				Dashboard_GUI.showhighscore();
+			}
+		});
+		
+		
+		
+		startlabel.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				System.out.println("GUI: Start ge<67>ffnet");
+				Dashboard_GUI.showstart();
+			}
+		});
+		
+		
+		
+		texturenlabel.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				texturenauswaehlen_GUI texturenauswahl = new texturenauswaehlen_GUI(texturenpakete);
+				texturenauswahl.setVisible(true);
+			}
+		});
+		
+  }
 }

src/de/jaujau/gui/Hilfe_GUI.java

@@ -1,34 +1,46 @@
 package de.jaujau.gui;
 
-import java.util.*;
+import java.awt.BorderLayout;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.border.EmptyBorder;
+import javax.swing.JLabel;
+import javax.swing.SwingConstants;
+import java.awt.Font;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
 
+public class Hilfe_GUI extends JFrame {
 
-/**
- * Class Hilfe_GUI
+	/**
+	 * 
 	 */
-public class Hilfe_GUI {
+	private static final long serialVersionUID = 1L;
+	private JPanel contentPane;
 
-  //
-  // Fields
-  //
+	/**
+	 * Create the frame.
+	 */
+	public Hilfe_GUI() {
+		setAlwaysOnTop(true);
+		setBounds(100, 100, 588, 382);
+		contentPane = new JPanel();
+		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
+		contentPane.setLayout(new BorderLayout(0, 0));
+		setContentPane(contentPane);
 		
+		JLabel lblNewLabel = new JLabel("Hilfe");
+		lblNewLabel.setFont(new Font("Tahoma", Font.PLAIN, 20));
+		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
+		contentPane.add(lblNewLabel, BorderLayout.NORTH);
 		
-  //
-  // Constructors
-  //
-  public Hilfe_GUI () { };
+		JScrollPane scrollPane = new JScrollPane();
+		contentPane.add(scrollPane, BorderLayout.CENTER);
 		
-  //
-  // Methods
-  //
-
-
-  //
-  // Accessor methods
-  //
-
-  //
-  // Other methods
-  //
+		JTextArea txtrJaujauJaujauIst = new JTextArea();
+		txtrJaujauJaujauIst.setEditable(false);
+		txtrJaujauJaujauIst.setText("JauJau\r\nJauJau ist ein Java basiertes Spiel was nach auf dem Spielprinzip von MauMau aufbaut.\r\n\r\nProduktvision\r\nJauJau - \"Java-MauMau\" Interaktives Spieldesign, welches die traditionellen\r\nSpielmechaniken von MauMau digitalisiert und es m\u00F6glich macht auch alleine den\r\nbeliebten Klassiker zu spielen. Individuell - durch Spielerfolg Freischaltung\r\nneuer Kartendesigns.\r\n\r\nSpielidee\r\n\r\nKartenspiel auf Basis von MauMau.\r\nEin Spieler spielt gegen eine Computer Spieler\r\nDie Punktest\u00E4nde der Spieler werden Gespeichert\r\nMit h\u00F6heren Punktestand werden zus\u00E4tzliche Kartentexturenpakete freigeschaltete\r\n\r\n\r\nSpielregeln\r\nAkionskarten:\r\n\r\n7 - zwei ziehen\r\n8 - Aussetzen\r\nBube - W\u00FCnscher\r\n\r\nZusatzregeln:\r\n\r\n9 - Richtungswechsel\r\n8 - Stopper hebt Aktionskarte 7 \"zwei ziehen\" auf\r\n10 - Allesleger (darf auf jede Karte gelegt werden)\r\n\r\n\r\nFeatures\r\n\r\nAutomatischer \"Jau\" Ausruf bei letzter Karte und \"JauJau\" beim Ablegen der letzten\r\nverschiedene Texturenpackete f\u00FCr Kartens\u00E4tze\r\n\r\n\r\nAnforderungen\r\n\r\nKompatibel mit verschieden Betriebssystemen\r\nSkalierung der GUI\r\nJava 11 Support");
+		scrollPane.setViewportView(txtrJaujauJaujauIst);
+	}
 
 }

src/de/jaujau/gui/Menue_GUI.java

@@ -1,123 +0,0 @@
-package de.jaujau.gui;
-
-import java.awt.EventQueue;
-import java.awt.Image;
-
-import javax.swing.JFrame;
-import javax.swing.JButton;
-import java.awt.BorderLayout;
-import javax.swing.JPanel;
-import javax.imageio.ImageIO;
-import javax.swing.BoxLayout;
-import javax.swing.Icon;
-
-import java.awt.Color;
-import java.awt.Dimension;
-import javax.swing.JLabel;
-import javax.swing.ImageIcon;
-import javax.swing.SwingConstants;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.net.URL;
-import java.awt.Component;
-import java.awt.Font;
-
-public class Menue_GUI {
-
-	private JFrame frame;
-
-	/**
-	 * Launch the application.
-	 */
-	public static void main(String[] args) {
-		EventQueue.invokeLater(new Runnable() {
-			public void run() {
-				try {
-					Menue_GUI window = new Menue_GUI();
-					window.frame.setVisible(true);
-				} catch (Exception e) {
-					e.printStackTrace();
-				}
-			}
-		});
-	}
-
-	/**
-	 * Create the application.
-	 */
-	public Menue_GUI() {
-		initialize();
-	}
-
-	/**
-	 * Initialize the contents of the frame.
-	 */
-	
-	
-	//Test GUI f<>r JauJau
-	
-	
-	private void initialize() {
-		frame = new JFrame();
-		frame.setBounds(100, 100, 783, 762);
-		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-		frame.getContentPane().setLayout(new BorderLayout(0, 0));
-		
-		JPanel panel_top = new JPanel();
-		panel_top.setPreferredSize(new Dimension(200, 100));
-		panel_top.setBackground(new Color(0, 0, 128));
-		frame.getContentPane().add(panel_top, BorderLayout.NORTH);
-		panel_top.setLayout(new BorderLayout(0, 0));
-		
-		JLabel lblNewLabel_1 = new JLabel("JauJau");
-		lblNewLabel_1.setForeground(Color.WHITE);
-		lblNewLabel_1.setHorizontalAlignment(SwingConstants.CENTER);
-		lblNewLabel_1.setInheritsPopupMenu(false);
-		lblNewLabel_1.setIgnoreRepaint(false);
-		lblNewLabel_1.setFont(new Font("Tahoma", Font.BOLD, 40));
-		lblNewLabel_1.setVerticalAlignment(SwingConstants.CENTER);
-		panel_top.add(lblNewLabel_1, BorderLayout.CENTER);
-		
-		JPanel panel_side = new JPanel();
-		panel_side.setBackground(new Color(100, 149, 237));
-		panel_side.setPreferredSize(new Dimension(200, 400));
-		frame.getContentPane().add(panel_side, BorderLayout.WEST);
-		panel_side.setLayout(new BorderLayout(0, 0));
-		
-		JPanel panel_buttons = new JPanel();
-		panel_buttons.setBackground(new Color(0, 0, 128));
-		panel_buttons.setPreferredSize(new Dimension(50, 200));
-		panel_side.add(panel_buttons, BorderLayout.WEST);
-		panel_buttons.setLayout(new BorderLayout(0, 0));
-		
-		JPanel panel = new JPanel();
-		panel.setBackground(new Color(0, 0, 153));
-		panel.setPreferredSize(new Dimension(50, 50));
-		panel_buttons.add(panel, BorderLayout.NORTH);
-		panel.setLayout(new BorderLayout(0, 0));
-		
-
-		JLabel lblNewLabel = new JLabel("");
-		lblNewLabel.addMouseListener(new MouseAdapter() {
-			@Override
-			public void mouseClicked(MouseEvent e) {
-				panel_side.setVisible(false);
-			}
-		});
-		lblNewLabel.setPreferredSize(new Dimension(50, 50));
-		lblNewLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
-		lblNewLabel.setHorizontalTextPosition(SwingConstants.CENTER);
-		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
-		ImageIcon imageIcon = new ImageIcon(new ImageIcon("C:\\Users\\Elmar\\Pictures\\exit.png").getImage().getScaledInstance(40, 40, Image.SCALE_DEFAULT));
-		lblNewLabel.setIcon(imageIcon);
-		panel.add(lblNewLabel, BorderLayout.CENTER);
-		
-		JPanel panel_main = new JPanel();
-		panel_main.setPreferredSize(new Dimension(600, 600));
-		frame.getContentPane().add(panel_main, BorderLayout.CENTER);
-	}
-
-}

src/de/jaujau/gui/Navigation_GUI.java

@@ -0,0 +1,126 @@
+package de.jaujau.gui;
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import javax.swing.JPanel;
+import javax.swing.SwingConstants;
+import java.awt.BorderLayout;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import javax.swing.JLabel;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.GridLayout;
+import java.awt.Image;
+import javax.swing.BoxLayout;
+import java.awt.Component;
+import javax.swing.ImageIcon;
+
+
+public class Navigation_GUI
+extends JPanel
+implements ActionListener {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	private JPanel panel;
+
+	
+	// Konstruktor
+	public Navigation_GUI() {
+		
+		// Hiermit bekommst du Zugriff auf das <20>bergebene Objekt mainPanel
+		setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
+		
+		panel = new JPanel();
+		panel.setBackground(new Color(102, 153, 204));
+		add(panel);
+		panel.setLayout(new BorderLayout(0, 0));
+		
+		JPanel panel_side = new JPanel();
+		panel_side.setBackground(new Color(100, 149, 237));
+		panel_side.setPreferredSize(new Dimension(200, 400));
+		panel.add(panel_side, BorderLayout.CENTER);
+		panel_side.setLayout(new BorderLayout(0, 0));
+		
+		JPanel panel_buttons = new JPanel();
+		panel_buttons.setBackground(new Color(0, 0, 128));
+		panel_buttons.setPreferredSize(new Dimension(50, 200));
+		panel_side.add(panel_buttons, BorderLayout.WEST);
+		panel_buttons.setLayout(new BorderLayout(0, 0));
+		
+		JPanel panel = new JPanel();
+
+		panel.setBackground(new Color(0, 0, 153));
+		panel.setPreferredSize(new Dimension(50, 50));
+		panel_buttons.add(panel, BorderLayout.NORTH);
+		panel.setLayout(new BorderLayout(0, 0));
+		
+
+		JLabel lblNewLabel = new JLabel("");
+		lblNewLabel.setPreferredSize(new Dimension(50, 50));
+		lblNewLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+		lblNewLabel.setHorizontalTextPosition(SwingConstants.CENTER);
+		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
+		ImageIcon imageIcon = new ImageIcon(new ImageIcon("C:\\Users\\Elmar\\Pictures\\exit.png").getImage().getScaledInstance(40, 40, Image.SCALE_DEFAULT));
+		lblNewLabel.setIcon(imageIcon);
+		panel.add(lblNewLabel, BorderLayout.CENTER);
+		
+		JPanel panel_1 = new JPanel();
+		panel_side.add(panel_1, BorderLayout.CENTER);
+		
+		JPanel panel_2 = new JPanel();
+		panel_2.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+			}
+		});
+		panel_2.setBackground(new Color(0, 102, 204));
+		
+		JLabel lblNewLabel_1 = new JLabel("Start");
+		lblNewLabel_1.setBackground(new Color(0, 102, 204));
+		lblNewLabel_1.setForeground(Color.WHITE);
+		lblNewLabel_1.setFont(new Font("Tahoma", Font.PLAIN, 20));
+		panel_2.add(lblNewLabel_1);
+		
+		JLabel label = new JLabel("");
+		
+		JPanel panel_3 = new JPanel();
+		panel_3.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+			}
+		});
+		panel_3.setBackground(new Color(0, 102, 204));
+		
+		JLabel lblNewLabel_2 = new JLabel("Highscore");
+		lblNewLabel_2.setForeground(new Color(255, 255, 255));
+		lblNewLabel_2.setFont(new Font("Tahoma", Font.PLAIN, 20));
+		panel_3.add(lblNewLabel_2);
+		panel_1.setLayout(new GridLayout(0, 1, 0, 0));
+		panel_1.add(panel_2);
+		
+		JLabel label_1 = new JLabel("");
+		panel_1.add(label_1);
+		
+		JLabel label_2 = new JLabel("");
+		panel_1.add(label_2);
+		panel_1.add(label);
+		panel_1.add(panel_3);
+
+		
+		//Schlie<69>e Button Panel
+		panel.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				panel_1.setVisible(false);
+			}
+		});
+	}
+
+	// In dieser Methode <20>nderst du das anzuzeigende Panel
+	// <20>ber die showPanel-Methode in mainPanel
+	public void actionPerformed(ActionEvent e) {
+	}
+}

src/de/jaujau/gui/Spiel_GUI.java

@@ -1,34 +0,0 @@
-package de.jaujau.gui;
-
-import java.util.*;
-
-
-/**
- * Class Spiel_GUI
- */
-public class Spiel_GUI {
-
-  //
-  // Fields
-  //
-
-  
-  //
-  // Constructors
-  //
-  public Spiel_GUI () { };
-  
-  //
-  // Methods
-  //
-
-
-  //
-  // Accessor methods
-  //
-
-  //
-  // Other methods
-  //
-
-}

src/de/jaujau/gui/texturenauswaehlen_GUI.java

@@ -1,34 +1,132 @@
 package de.jaujau.gui;
 
-import java.util.*;
+import java.awt.BorderLayout;
+import java.awt.Font;
+import java.awt.Image;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
 
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.SwingConstants;
+import javax.swing.border.EmptyBorder;
+
+import de.jaujau.daten.Texturenpakete;
+import javax.swing.JComboBox;
+import javax.swing.JFileChooser;
 
 /**
- * Class texturenauswaehlen_GUI
+ * Klasse texturenauswaehlen_GUI
  */
-public class texturenauswaehlen_GUI {
+public class texturenauswaehlen_GUI extends JFrame{
 
-  //
-  // Fields
-  //
+	private static final long serialVersionUID = 1L;
+	private JPanel contentPane;
+	private Texturenpakete pakete;
+	private JComboBox comboBox;
+	private JLabel vorschaubild;
+	private JButton speichern, hinzufuegen, schliessen;
+	
+	public texturenauswaehlen_GUI (Texturenpakete texturenpakete) {
+		pakete = texturenpakete;
+		erstelleFenster();
+		aktualisiereInhalt();
+	}
 	
 	
-  //
-  // Constructors
-  //
-  public texturenauswaehlen_GUI () { };
+	private void erstelleFenster() {
+		//Fenster größen fetslegen
+		setAlwaysOnTop(true);
+		setBounds(100, 100, 588, 558);
+		contentPane = new JPanel();
+		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
+		setContentPane(contentPane);
+		contentPane.setLayout(null);
+		setResizable(false);
 		
-  //
-  // Methods
-  //
+		//Vorschaubild
+		vorschaubild = new JLabel();
+		vorschaubild.setBounds(117, 111, 167, 214);
+		contentPane.add(vorschaubild);
+		
+		//Text "Texturenauswahl"
+		JLabel lblNewLabel = new JLabel("Texturenauswahl");
+		lblNewLabel.setBounds(5, 5, 562, 25);
+		lblNewLabel.setFont(new Font("Tahoma", Font.PLAIN, 20));
+		lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
+		contentPane.add(lblNewLabel);
+		
+		//Teste Hinzufügen
+		hinzufuegen = new JButton("Hinzuf\u00FCgen");
+		hinzufuegen.setBounds(309, 125, 137, 23);
+		hinzufuegen.addActionListener(e-> paketHinzufuegeb());
+		contentPane.add(hinzufuegen);
 		
 		
-  //
-  // Accessor methods
-  //
+		//Teste Speichern
+		speichern = new JButton("Speichern");
+		speichern.setBounds(306, 231, 140, 23);
+		speichern.addActionListener(e-> speichern());
+		contentPane.add(speichern);
 		
-  //
-  // Other methods
-  //
 		
+		//Teste Schießen
+		schliessen = new JButton("Schlie\u00DFen");
+		schliessen.setBounds(306, 177, 140, 23);
+		schliessen.addActionListener(e-> schliessen());
+		contentPane.add(schliessen);
+		
+		
+		//Auswahl Box
+		comboBox = new JComboBox();
+		comboBox.setBounds(117, 69, 351, 25);
+		contentPane.add(comboBox);
+		
+		aktualisiereInhalt();
+	}
+	
+	private void paketHinzufuegeb() {
+		//Quelle: https://www.java-tutorial.org/jfilechooser.html
+		
+        // JFileChooser-Objekt erstellen
+        JFileChooser chooser = new JFileChooser();
+        // Dialog zum Oeffnen von Dateien anzeigen
+        int chooseroption = chooser.showOpenDialog(null);
+        // Abfrage, ob auf "Öffnen" geklickt wurde
+        if(chooseroption == JFileChooser.APPROVE_OPTION)
+        {
+        	pakete.addPaket(chooser.getSelectedFile().toString());
+        	aktualisiereInhalt();
+        }
+		
+	}
+	
+	
+	private void schliessen() {
+		this.setVisible(false);
+	}
+	
+	
+	private void speichern() {
+		pakete.setAktivesPaket(comboBox.getSelectedIndex());
+		aktualisiereBild();
+		
+	}
+	
+	private void aktualisiereInhalt() {
+		comboBox.removeAllItems();
+		for(int i = 0; i < pakete.getAnzahlPakete(); i++) {
+			comboBox.addItem(pakete.getName(i));
+		}
+		comboBox.setSelectedIndex(pakete.getAktivesPaket());
+		aktualisiereBild();
+	}
+	
+	
+	private void aktualisiereBild() {
+		vorschaubild.setIcon(new ImageIcon(pakete.getTextur(32).getScaledInstance(150, 210, Image.SCALE_SMOOTH)));
+	}
 }

src/de/jaujau/spiellogik/Anwendung.java

@@ -1,113 +1,43 @@
-package de.jaujau.spiellogik;
+/**
 
-import java.util.*;
+ * @author Alaa Aldin
+
+ * @version 1.0
+
+ */
+package de.jaujau.spiellogik;
 
 import de.jaujau.daten.Spielerverwaltung;
 import de.jaujau.daten.Texturenpakete;
 import de.jaujau.gui.GUI;
+//import de.jaujau.gui.Menue_GUI;
+//import de.jaujau.gui.Spiel_GUI;
 
-
-/**
- * Class Anwendung
- */
 public class Anwendung {
 
-  //
-  // Fields
-  //
-
-  private Spiel aktuellesSpiel;
   private Texturenpakete texturenpakete;
   private Spielerverwaltung speicherung;
-  private GUI gui;
+  private GUI view;
+  
 
   //
   // Constructors
   //
-  public Anwendung () { };
-  
-  //
-  // Methods
-  //
+  public Anwendung() {
+	  speicherung = new Spielerverwaltung();
+	  texturenpakete = new Texturenpakete();
+	  view = new GUI(texturenpakete, speicherung);
     
 	
-  //
-  // Accessor methods
-  //
-
-  /**
-   * Set the value of aktuellesSpiel
-   * @param newVar the new value of aktuellesSpiel
-   */
-  public void setAktuellesSpiel (Spiel newVar) {
-    aktuellesSpiel = newVar;
-  }
-
-  /**
-   * Get the value of aktuellesSpiel
-   * @return the value of aktuellesSpiel
-   */
-  public Spiel getAktuellesSpiel () {
-    return aktuellesSpiel;
-  }
-
-  /**
-   * Set the value of texturenpakete
-   * @param newVar the new value of texturenpakete
-   */
-  public void setTexturenpakete (Texturenpakete newVar) {
-    texturenpakete = newVar;
-  }
-
-  /**
-   * Get the value of texturenpakete
-   * @return the value of texturenpakete
-   */
-  public Texturenpakete getTexturenpakete () {
-    return texturenpakete;
-  }
-
-  /**
-   * Set the value of speicherung
-   * @param newVar the new value of speicherung
-   */
-  public void setSpeicherung (Spielerverwaltung newVar) {
-    speicherung = newVar;
-  }
-
-  /**
-   * Get the value of speicherung
-   * @return the value of speicherung
-   */
-  public Spielerverwaltung getSpeicherung () {
-    return speicherung;
-  }
-
-  /**
-   * Set the value of gui
-   * @param newVar the new value of gui
-   */
-  public void setGui (GUI newVar) {
-    gui = newVar;
-  }
-
-  /**
-   * Get the value of gui
-   * @return the value of gui
-   */
-  public GUI getGui () {
-    return gui;
-  }
-
-  //
-  // Other methods
-  //
-
+  };
   /**
    */
-  public void main()
-  {
+  public static void main(String[] args) {
+	/**
+     * Launch the application.
+     */
+	  
+	  Anwendung jaujau = new Anwendung();
+	  jaujau.view.setVisible(true);
   }
-
-
 }

src/de/jaujau/spiellogik/Computer_gegner.java

@@ -1,37 +1,42 @@
 package de.jaujau.spiellogik;
 
-import java.util.*;
 
+
+import java.util.ArrayList;
+import java.util.Random;
+
+import de.jaujau.daten.Farbe;
 import de.jaujau.daten.Kartensatz;
+import de.jaujau.daten.Spieler;
+import de.jaujau.daten.Wert;
 
 
 /**
- * Class Computer_gegner
+ * Diese Klasse steuert den Computer Gegner
+ * @author Moritz K<>ppe
  */
 public class Computer_gegner {
 
   //
   // Fields
   //
-
-  
+  private Wert letztekartewert;
+  private Farbe letztekartefarbe;
+  private ArrayList<Integer> hand;
+  private ArrayList<Integer> gegnerhand;
+  private boolean farbeInHand = false;
+  private boolean wertInHand = false;
+  private boolean bubeInHand = false;
+  private Kartensatz kartensatz;
+  private boolean siebenInHand;
+  private boolean achtInHand;
   //
   // Constructors
   //
-  public Computer_gegner () { };
+  public Computer_gegner (Kartensatz karten) { 
+	  kartensatz = karten;
+  };
   
-  //
-  // Methods
-  //
-
-
-  //
-  // Accessor methods
-  //
-
-  //
-  // Other methods
-  //
   
   /**
    * @param        kartensatz
@@ -39,6 +44,236 @@ public class Computer_gegner {
   public void pruefeZug(Kartensatz kartensatz)
   {
   }  
+  /**
+   * Funktion sucht aus, welche Karte der Computer Gegner legt, nach verschiedenen Parametern
+   * Zuerst sollen Karten gelegt werden, welche den aktuell geltenden Effekt kontern, falls einer liegt
+   * Danach werden Effektkarten der aktuellen Farbe gelegt
+   * Als n<>chstes Werden Karten der aktuellen Farbe gelegt
+   * Dann Karten die den aktuellenw Wert besitzen
+   * Zuletzt Buben um sich eine Farbe zu w<>nschen
+   * @param boolean, muss Spieler ziehen?
+   * @param boolean, muss Spieler aussetzen?
+   * @return Kartenindex der Karte die gelegt werden soll
+   */
+  public int cpu_Zug(boolean ziehen, boolean aussetzen, Kartensatz karten) {
+	  kartensatz = karten; 																	//Erzeugt ein Abbild des aktuellen Kartensatzes, mit Stand der Karten
+	  letztekartewert = kartensatz.getKarte(kartensatz.getletzteKarte()).getWERT();			//Speichert den Wert der Karte, die zuletzt gelegt wurde
+	  letztekartefarbe = kartensatz.getKarte(kartensatz.getletzteKarte()).getFARBE(); 		//Speichert die Farbe der Karte, die zuletzt gelegt wurde
+	  hand = kartensatz.getHand(Spieler.COMPUTER);											//Speichert die Karten, die der Computer aktuell auf der Hand hat
+	  farbeInHand = false;																	//Speichert, ob die aktuell liegende Farbe in der Hand des Computers vorhanden ist
+	  wertInHand = false;																	//Speichert, ob der aktuell liegende Wert in der Hand des Computers vorhanden ist
+	  int rueckgabeindex = -1;																//Speichert den Kartenindex, der Karte, die gelegt werden soll. Standard -1 f<>r ziehen, falls keine passende Karte auf Hand 
+	  bubeInHand = false;																	//Speichert, ob ein Bube in der Hand vorhanden ist
+	  gegnerhand = kartensatz.getHand(Spieler.SPIELER);								
 	  
 	  
+	  achtInHand  = false;	  
+	  siebenInHand = false;
+	  
+	  for(int i = 0; i < hand.size(); i++) {												//Schleife geht alle Karten in der Hand des Computers durch
+		  Farbe farbeHK = kartensatz.getKarte(hand.get(i)).getFARBE();						//Holt sich die Farbe der aktuellen Handkarte
+		  Wert wertHK = kartensatz.getKarte(hand.get(i)).getWERT();							//Holt sich den Wert der aktuellen Handkarte
+		  
+		  if(farbeHK == letztekartefarbe && wertHK != Wert.BUBE) {							//Pr<50>ft ob Farbe der aktuellen Handkarte zur offen liegenden Karte passt
+			  farbeInHand = true;
+		  }
+		  
+		  if(wertHK == letztekartewert) {													//Pr<50>ft ob Wert der aktuellen Handkarte zur liegenden Karte passt
+			  wertInHand = true;
+		  }
+		  
+		  if(wertHK == Wert.BUBE) {															//Pr<50>ft, ob ein Bube (W<>nscher) auf der Hand vorhanden ist
+			  bubeInHand = true;
+		  }
+		  
+		  //Sollte der Computer genau eine 8 und eine weitere Karte der selben Farbe (keine Buben) haben, wird er versuchen diese 8 pr<70>feriert zu legen
+		  if(((wertHK == Wert.ACHT && farbeHK == letztekartefarbe) || (wertHK == Wert.ACHT && letztekartewert == Wert.ACHT)) && farbeZahl(farbeHK) == 2) {
+			  achtInHand = true;
+		  }
+		  
+		  if((wertHK == Wert.SIEBEN && farbeHK == letztekartefarbe) || (wertHK == Wert.SIEBEN && letztekartewert == Wert.SIEBEN)) {
+			  siebenInHand = true;
+		  }
+	  }
+	  
+	  
+	  
+	  if(achtInHand && !ziehen) {
+		  for (int i = 0; i < hand.size(); i++) {
+			  Farbe farbeHK = kartensatz.getKarte(hand.get(i)).getFARBE();
+			  Wert wertHK = kartensatz.getKarte(hand.get(i)).getWERT();
+			  if((farbeHK == letztekartefarbe && wertHK == Wert.ACHT) || (wertHK == letztekartewert && wertHK == Wert.ACHT)) {
+				  System.out.println("COMPUTER: Ausnahme 1");
+				  return hand.get(i);
+			  }
+		  }
+	  }
+	  
+	  
+	  //Hat der Spieler noch genau eine oder zwei Karten auf der Hand, wird der Bot versuchen eine 7 zu legen	  
+	  if(gegnerhand.size() < 3 && siebenInHand && !aussetzen) {
+		  for (int i = 0; i < hand.size(); i++) {
+			  Farbe farbeHK = kartensatz.getKarte(hand.get(i)).getFARBE();
+			  Wert wertHK = kartensatz.getKarte(hand.get(i)).getWERT();
+			  if((farbeHK == letztekartefarbe && wertHK == Wert.SIEBEN) || (wertHK == letztekartewert && wertHK == Wert.SIEBEN)) {
+				  System.out.println("COMPUTER: Ausnahme 2");
+				  return hand.get(i);
+			  }
+		  }
+	  }
+	  
+	  
+	  
+	  
+	  //W<>hlt aus, welche Karte gelegt wird
+	  if ((aussetzen || ziehen) && wertInHand) {											//Muss der Computer aussetzen oder ziehen, versucht er eine passende Konterkarte zu legen											
+		  rueckgabeindex = wertLegen(letztekartewert);
+		  System.out.println("COMPUTER: Fall 1");
+	  }
+	  else if((wertInHand || farbeInHand) && !aussetzen && !ziehen) {	
+		  
+		  if (hand.size() > 3) {															//Hat der Computer viele Karten in der Hand versucht er passende Farben zu legen, bei weniger Karten passende Werte
+			  if(farbeInHand && !aussetzen && !ziehen) {									//Hat der Computer die Farbe auf der Hand, versucht er diese zu legen
+				  rueckgabeindex = farbeLegen(letztekartefarbe);
+				  System.out.println("COMPUTER: Fall 2");
+			  }
+			  else if(wertInHand && !aussetzen && !ziehen) {								//Hat der Computer nicht die passende Farbe, aber einen passenden Wert, legt er diesen
+				  rueckgabeindex = wertLegen(letztekartewert);
+				  System.out.println("COMPUTER: Fall 3");
+			  }
+		  }
+		  else {
+			  if(wertInHand && !aussetzen && !ziehen) {										//Hat der Computer die Wert auf der Hand, versucht er diese zu legen
+				  rueckgabeindex = wertLegen(letztekartewert);
+				  System.out.println("COMPUTER: Fall 4");
+			  }
+			  else if(farbeInHand && !aussetzen && !ziehen) {								//Hat der Computer nicht den passenden Wert, aber eine passende Farbe, legt er diese
+				  rueckgabeindex = farbeLegen(letztekartefarbe);
+				  System.out.println("COMPUTER: Fall 5");
+			  }
+			  
+		  }
+	  }
+	  else if(bubeInHand && !aussetzen && !ziehen) {										//Hat der Computer weder die passende Farbe, noch den passenden Wert auf der Hand, aber einen W<>nscher, legt er diesen
+		  rueckgabeindex = wertLegen(Wert.BUBE);
+		  System.out.println("COMPUTER: Fall 6");
+	  }
+	  else if(aussetzen && !wertInHand) {													//Muss der Computer aussetzen und kann nicht reagieren, gibt er eine -2 zur<75>ck
+		  rueckgabeindex = -2;
+		  System.out.println("COMPUTER: Fall 7");
+	  }
+	  
+	  
+	  
+	  return rueckgabeindex;																		
+  }
+  
+  /**
+   * Funktion sucht Karte passend zur gesuchten Farbe aus der Hand und gibt diese zur<75>ck
+   * Passen mehrere Karten, gibt sie die letzte passende zur<75>ck
+   * @param Farbe, Farbe zu der eine Karte gesucht wird
+   * @return integer Index der zur<75>ckgegebenen Karte
+   */
+  private int farbeLegen(Farbe gesuchteFarbe) {
+	  int ind = -1;
+	  
+	  for(int i = 0; i < hand.size(); i++) {
+		  Farbe farbeHK = kartensatz.getKarte(hand.get(i)).getFARBE();
+		  Wert wertHK = kartensatz.getKarte(hand.get(i)).getWERT();
+		  if(farbeHK == gesuchteFarbe && wertHK != Wert.BUBE) {
+			  ind = hand.get(i);
+		  }
+	  }
+	  return ind;
+  }
+  
+  /**
+   * Funktion sucht Karte passend zum gesuchten Wert aus der Hand und gibt diese zur<75>ck
+   * Passen mehrere Karten, gibt sie die letzte passende zur<75>ck
+   * @param Wert, Wert zu dem eine passende Karte gesucht wird
+   * @return integer Index der zur<75>ckgegebenen Karte
+   */
+  private int wertLegen(Wert gesuchterWert) {
+	  int ind = -1;
+	  
+	  for(int i = 0; i < hand.size(); i++) {
+		  Wert wertHK = kartensatz.getKarte(hand.get(i)).getWERT();
+		  if(wertHK == gesuchterWert) {
+			  ind = hand.get(i);
+		  }
+	  }
+	  return ind;
+  }
+  
+  /**
+   * Funktion w<>hlt f<>r den Computer aus, welche Farbe er sich bei einem W<>nscher aussucht
+   * Dazu wird geschaut, von welcher Farbe er am meisten Karten auf der Hand hat
+   * @param Kartensatz aktueller Stand des Kartensatzes
+   * @return Farbe gew<65>hlte Farbe
+   */
+  public Farbe farbeAussuchen(Kartensatz karten) {
+	  kartensatz = karten;
+	  Farbe wahl = Farbe.KREUZ;	
+	  hand = kartensatz.getHand(Spieler.COMPUTER);											//Speichert die Karten, die der Computer aktuell auf der Hand hat
+	  
+	  int hoechsteAnzahl = 0;
+	  int anzahl = 0;
+	  
+	  Farbe[] farben = {Farbe.KREUZ, Farbe.PIK, Farbe.HERZ, Farbe.KARO};
+	  
+	  for (int i = 0; i < farben.length; i++) {
+		  anzahl = farbeZahl(farben[i]);
+		  if (anzahl > hoechsteAnzahl) {
+			  hoechsteAnzahl = anzahl;
+			  wahl = farben[i];
+		  }
+		  if (hand.size() < 3) {
+			  if(zufall(10) > 11) {
+				  wahl = farben[zufall(4)];
+			  }
+		  }
+	  }
+	  
+	  return wahl;
+  }
+  
+  /**
+   * Funktion, die eine zuf<75>llige Zahl zwischen 0 und einer andere Zahl r-1 ausgibt
+   * @param int r 
+   * @return int zuf<75>llige Zahl
+   */
+  private int zufall(int r){
+		Random zufall = new Random();
+		
+		int diced = 0;
+		diced = zufall.nextInt(r);
+		return diced;
+	}
+  
+  /**
+   * Funktion z<>hlt f<>r die jeweilige Farbe, wie viele Karten der Farbe auf der Hand des Computer sind
+   * @param farbe, f<>r welche gez<65>hlt werden soll
+   * @return integer Wie viele Karten der Farbe auf der Hand sind
+   */
+  private int farbeZahl(Farbe farbe) {
+	  int anzahl = 0;
+	  
+	  for (int i = 0; i < hand.size(); i++) {
+		  Farbe farbeHK = kartensatz.getKarte(hand.get(i)).getFARBE();
+		  Wert wertHK = kartensatz.getKarte(hand.get(i)).getWERT();
+		  if (farbeHK == farbe && wertHK != Wert.BUBE) {
+			  anzahl ++;
+		  }
+	  }
+	  
+	  return anzahl;
+  }
+  /**
+   * Dies ist nur eine Testfunktion
+   * @return Integer, gibt immer 1 zur<75>ck
+   */
+  public int cpuTest() {
+	  return 1;
+  }
+
 }

src/de/jaujau/spiellogik/Spiel.java

@@ -1,16 +1,264 @@
 package de.jaujau.spiellogik;
 
-import java.util.*;
+import java.util.Random;
 
+import de.jaujau.daten.Audio;
+import de.jaujau.daten.Farbe;
 import de.jaujau.daten.Kartensatz;
+import de.jaujau.daten.Spieler;
+import de.jaujau.daten.Wert;
+import de.jaujau.gui.Dashboard_GUI;
+
 
 
 /**
- * Class Spiel
+ * Diese Klasse organisiert den Spielablauf
+ * Diese Klasse beinhaltet Methoden um Spielz<6C>ge auszuf<75>hren, um Kontrollen durchzuf<75>hren und um zwischen Spieler und Computer zu wechseln
+ * @author Fabian Keller 
  */
 public class Spiel {
 
+	private Spieler amZug;
+	private Wert gelegterWert;
+	private Audio audio;
+	private Kartensatz kartensatz;
+	private Spielzug spielzug;
+	private Computer_gegner computerGegner;
+	private boolean aussetzen;
+	private boolean zwei_ziehen;
+	private int kartenZiehen;
+	private Dashboard_GUI dashboard;
+	private boolean spielGewonnen;
+	
+	public Spiel(Dashboard_GUI dashboard_gui) {
+		audio = new Audio();
+		kartensatz = new Kartensatz();
+		computerGegner = new Computer_gegner(kartensatz);
+		spielzug = new Spielzug(kartensatz);
+		dashboard = dashboard_gui;
+		spielGewonnen = false;
+	}
+	
+	public boolean getAussetzen() {
+		return aussetzen;
+	}
 
 
+	public boolean getZwei_ziehen() {
+		return zwei_ziehen;
+	}
 
+	
+	public Kartensatz getKartensatz() {
+		return kartensatz;
+	}
+
+
+	public Spieler getamZug() {
+		return amZug;		
+	}
+	
+	
+	/**
+	 * Initialisiert ein Spiel
+	 * Handelt den Start aus und f<>hrt, falls n<>tig, den ersten Spielzug aus
+	 * @param dashboard
+	 */
+	public void spiel(Dashboard_GUI dashboard) {
+		System.out.println("\nSPIEL Spiel gestartet.");
+		Random zufallszahl = new Random();
+		int zahl = zufallszahl.nextInt(2);
+		if(zahl == 1) { //Starter durch zufall bestimmen
+			amZug = Spieler.SPIELER;
+			System.out.println("SPIEL Spieler startet");
+		}
+		else { 
+			amZug = Spieler.COMPUTER;
+			System.out.println("SPIEL Computer startet");
+		}
+		for(int i = 0; i < 7; i++) { //Jeder bekommt 7 Karten
+			kartensatz.ziehen(Spieler.COMPUTER);
+			kartensatz.ziehen(Spieler.SPIELER);
+		}
+		System.out.println("SPIEL Kartenhand von COMPUTER: " + kartensatz.getHand(Spieler.COMPUTER));
+		System.out.println("SPIEL Kartenhand von SPIELER:  " + kartensatz.getHand(Spieler.SPIELER));
+		effekteSetzen();
+		if(amZug == Spieler.COMPUTER) {
+			int computerZug = computerGegner.cpu_Zug(zwei_ziehen, aussetzen, kartensatz);
+			System.out.println("\nSPIEL Computerauswahl: " + computerZug);
+			switch(computerZug) {
+			case -2: 
+				aussetzen = false;
+				alternieren(dashboard);
+				break;
+			case -1:
+				karteZiehen();
+				break;
+			default:
+				karteLegen(computerZug);
+				break;
+			}	
+		}
+		else if(amZug == Spieler.SPIELER) {
+			if(aussetzen) dashboard.showaussetzen(true);
+		}
+		return;			
+	}
+	
+	
+	/**
+	 * Organisiert den Spielablauf nach jedem g<>ltigen Zug
+	 * @param dashboard
+	 */
+	private void alternieren(Dashboard_GUI dashboard) {
+		if(spielGewonnen) return;
+		if(amZug == Spieler.SPIELER) {
+			amZug = Spieler.COMPUTER;
+			dashboard.aktualisiereGUI();
+			System.out.println("\nSPIEL Computer am Zug");
+			int computerZug = computerGegner.cpu_Zug(zwei_ziehen, aussetzen, kartensatz);
+			System.out.println("SPIEL Computerauswahl: " + computerZug);
+			switch(computerZug) {
+			case -2: 
+				aussetzen = false;
+				alternieren(dashboard);
+				break;
+			case -1:
+				karteZiehen();
+				break;
+			default:
+				karteLegen(computerZug);
+				break;
+			}	
+			
+		}
+		else {
+			amZug = Spieler.SPIELER;
+			dashboard.aktualisiereGUI();
+			System.out.println("\nSPIEL Spieler am Zug");
+			if(aussetzen) {
+				System.out.println("\nSPIEL Aussetzen m<>glich");
+				dashboard.showaussetzen(true);	
+				dashboard.aktualisiereGUI();
+			}
+		}
+	}
+	
+	
+	/**
+	 * Wird aufgerufen wenn das Spiel entschieden wurde, f<>hrt zum Spielende
+	 * @param spieler Spieler, welcher gewonnen hat
+	 */
+	private void gewinn(Spieler spieler) {
+		System.out.println("HERZLICHEN GL<47>CKWUNSCH " + spieler + ". DU HAST GEWONNEN");
+		dashboard.gewonnen(spieler);
+		spielGewonnen = true;
+	}
+	
+	
+	/**
+	 * Bietet die M<>glichkeit auszusetzen
+	 */
+	public void aussetzen() {
+		if(spielGewonnen) return;
+		aussetzen = false;
+		alternieren(dashboard);
+	}
+	
+	/**
+	   * falls eine Karte gelegt werden kann, wird diese gelegt 
+	   * @param       	kartenindex
+	   */
+	public void karteLegen(int kartenindex) {
+		if(spielGewonnen) return;
+ 		System.out.println("SPIEL Versuche Karte " + kartenindex + " zu legen");
+		if (spielzug.pruefeZug(kartenindex, zwei_ziehen, aussetzen, kartensatz)) { //gew<65>hlte Karte kann gelegt werden
+			System.out.println("SPIEL pruefeZug positiv");
+			System.out.println("SPIEL Lege Karte " + kartenindex);
+			kartensatz.ablegen(kartenindex);
+			if(kartensatz.getHand(amZug).size() == 1) { //Teilnehmer hat nur noch eine Karte
+				audio.spieleJau();
+			}
+			if(kartensatz.getHand(amZug).isEmpty()) { //Teilnehmer hat gewonnen
+				audio.spieleJauJau();
+				gewinn(amZug);
+				return;
+			}
+			System.out.println("SPIEL Kartenhand von COMPUTER: " + kartensatz.getHand(Spieler.COMPUTER));
+			System.out.println("SPIEL Kartenhand von SPIELER:  " + kartensatz.getHand(Spieler.SPIELER));
+			effekteSetzen();
+			if(kartensatz.getKarte(kartenindex).getWERT() == Wert.ACHT) { //Sonderfall: wiederholtes aussetzen 
+				if(amZug == Spieler.SPIELER)		dashboard.showaussetzen(false);
+			}
+			if(kartensatz.getKarte(kartenindex).getWERT() == Wert.BUBE) { //Sonderfall: W<>nscher wurde gelegt
+				if(amZug == Spieler.COMPUTER)	alternieren(dashboard);
+			}
+			else {
+				alternieren(dashboard);
+			}
+		}		
+	}
+	
+	
+	/**
+	   * falls eine oder mehrere Karten gezogen werden k<>nnen, wird dies f<>r den Teilnehmer ausgef<65>hrt 
+	   */
+	public void karteZiehen(){
+		if(spielGewonnen) return;
+		if(!aussetzen) {
+			if(zwei_ziehen) { //mehrere ziehen
+				System.out.println("\nSPIEL " + kartenZiehen + " Karten gezogen");
+				for(int i = 0; i < kartenZiehen; i++) {	
+					kartensatz.ziehen(amZug);
+				}
+				kartenZiehen = 0;
+				zwei_ziehen = false;	
+			}
+			else { //Normales ziehen
+				kartensatz.ziehen(amZug);
+				System.out.println("\nSPIEL 1 Karte gezogen");
+			}
+			alternieren(dashboard);
+		}
+		else { //ziehen nicht m<>glich
+			return;
+		}
+	}
+	
+	
+	/**
+	 * Setzt die W<>nscher Farbe
+	 * @param farbe
+	 */
+	public void wuenscher(Farbe farbe) {
+		System.out.println("\nSPIEL W<>nsche Farbe");
+		kartensatz.SetWunschfarbe(farbe);
+		alternieren(dashboard);
+		dashboard.aktualisiereGUI();
+	}
+	
+	
+	/**
+	   * setzt Effekt-Variablen und Wunschfarbe f<>r einen W<>nscher 
+	   */
+	private void effekteSetzen() {
+		if(spielGewonnen) return;
+		gelegterWert = kartensatz.getKarte(kartensatz.getletzteKarte()).getWERT();
+		if(gelegterWert == Wert.ACHT) {
+			aussetzen = true;
+		}
+		if(gelegterWert == Wert.SIEBEN) {
+			zwei_ziehen = true;
+			kartenZiehen += 2;
+		}
+		if(gelegterWert == Wert.BUBE) {
+			if(amZug == Spieler.COMPUTER) {
+				kartensatz.SetWunschfarbe(computerGegner.farbeAussuchen(kartensatz));
+			}
+			else {
+				dashboard.showwunsch(true);
+			}
+		}
+		System.out.println("\nSPIEL Effekte gesetzt:\nSPIEL Aussetzen: " + aussetzen + "\nSPIEL Zwei_Ziehen: " + zwei_ziehen + "\nSPIEL Anzahl: " + kartenZiehen);
+	}	
 }

src/de/jaujau/spiellogik/Spielzug.java

@@ -1,13 +1,18 @@
 package de.jaujau.spiellogik;
 
-import java.util.*;
-
 import de.jaujau.daten.Kartensatz;
 import de.jaujau.daten.Spielerdaten;
+import de.jaujau.daten.Wert;
+
+import java.util.ArrayList;
+
+import de.jaujau.daten.Farbe;
+import de.jaujau.daten.Spieler;
 
 
 /**
- * Class Spielzug
+ * Diese Klasse verwaltet Funktionen, die den Spielzug pr<70>fen
+ * @author Moritz K<>ppe
  */
 public class Spielzug {
 
@@ -15,11 +20,78 @@ public class Spielzug {
   // Fields
   //
 	
+  private Kartensatz kartensatz;
 	
  //
   // Constructors
   //
-  public Spielzug () { };
+  public Spielzug (Kartensatz karten) {
+	  kartensatz = karten;
+  };
+  
+  /**
+   * Funktion untersucht, ob die Karte die der Spieler zu legen versucht auch gelegt werden kann
+   * Sollte der Spieler gerade aussetzen m<>ssen, kann nur eine 8 gelegt werden
+   * Muss der Spieler zwei Karten ziehen, kann nur eine 7 gelegt werden
+   * Gilt nichts von beidem muss die Karte zur vorhergelegten passen
+   * @param kartenindex Index der Karte die gelegt werden soll
+   * @param boolean, muss Spieler ziehen?
+   * @param boolean, muss Spieler aussetzen?
+   * @return boolean
+   */
+  public boolean pruefeZug(int kartenindex, boolean ziehen, boolean aussetzen, Kartensatz karten) {
+
+	  kartensatz = karten;
+	  Farbe kartenfarbe = kartensatz.getKarte(kartenindex).getFARBE();
+	  Wert kartenwert = kartensatz.getKarte(kartenindex).getWERT();
+	  Wert letztekartewert = kartensatz.getKarte(kartensatz.getletzteKarte()).getWERT();
+	  Farbe letztekartefarbe = kartensatz.getKarte(kartensatz.getletzteKarte()).getFARBE();
+	  System.out.println("SPIELZUG: Versucht Karte f<>r Funktion: " + kartenindex);
+	  System.out.println("SPIELZUG: Letzte Karte f<>r Funktion: " + letztekartewert + " " + letztekartefarbe);
+	  
+	  if(aussetzen && kartenwert == Wert.ACHT) {
+		  System.out.println("SPIELZUG: Bedingung 1");
+		  return true;
+	  }
+	  else if(aussetzen && !(kartenwert == Wert.ACHT)) {
+		  System.out.println("SPIELZUG: Bedingung 2");
+		  return false;
+	  }
+	  else if (ziehen && kartenwert == Wert.SIEBEN) {
+		  System.out.println("SPIELZUG: Bedingung 3");
+		  return true;
+	  }
+	  else if (!aussetzen && !ziehen && ((kartenwert == letztekartewert || kartenfarbe == letztekartefarbe) || kartenwert == Wert.BUBE)) {
+		  System.out.println("SPIELZUG: Bedingung 4");
+		  System.out.println("SPIELZUG: Aussetzen: " + aussetzen + " ziehen:" + ziehen);
+		  return true;
+	  }
+	  else {
+		  System.out.println("SPIELZUG: Bedingung 5");
+		  return false;
+	  }
+  }
+  
+  /**
+   * Pr<50>ft, ob der Spieler eine Karte legen kann, indem jede Karte in der Hand des Spielers mit der Funktion pruefeZug gepr<70>ft wird
+   * @param spieler, Spieler am Zug 
+   * @param boolean, muss Spieler ziehen?
+   * @param boolean, muss Spieler aussetzen?
+   * @return boolean, wurde passende Karte gefunden?
+   */
+  public boolean zugMoeglich(Spieler spieler, boolean ziehen, boolean aussetzen, Kartensatz karten) {
+	  kartensatz = karten;
+	  boolean gefunden = false; 
+	  ArrayList<Integer> Hand = kartensatz.getHand(spieler);
+	  for (int i = 0; i < Hand.size(); i++) {
+		  if (pruefeZug(Hand.get(i), ziehen, aussetzen, karten)) {
+			  gefunden = true;
+		  }
+	  }
+	  return gefunden;
+  }
+  ////
+ 
   
   //
   // Methods