diff --git a/.classpath b/.classpath index 9b07da8..afbfe1a 100644 --- a/.classpath +++ b/.classpath @@ -2,5 +2,6 @@ + diff --git a/.project b/.project index a71a1b2..d95d958 100644 --- a/.project +++ b/.project @@ -14,4 +14,15 @@ org.eclipse.jdt.core.javanature + + + 1606897925456 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..19331e2 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding//src/de/jaujau/gui/Dashboard_GUI.java=UTF-8 diff --git a/StandartTexturenBeta3.zip b/StandartTexturenBeta3.zip new file mode 100755 index 0000000..0249a8e Binary files /dev/null and b/StandartTexturenBeta3.zip differ diff --git a/StandartTexturenFehler.zip b/StandartTexturenFehler.zip new file mode 100755 index 0000000..21fb433 Binary files /dev/null and b/StandartTexturenFehler.zip differ diff --git a/highscore.txt b/highscore.txt new file mode 100644 index 0000000..510cefa --- /dev/null +++ b/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 diff --git a/src/de/jaujau/UnitTests/TEST_Audio.java b/src/de/jaujau/UnitTests/TEST_Audio.java new file mode 100644 index 0000000..e5ab97d --- /dev/null +++ b/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); + } + + } + +} diff --git a/src/de/jaujau/UnitTests/TEST_Kartensatz.java b/src/de/jaujau/UnitTests/TEST_Kartensatz.java new file mode 100755 index 0000000..153da9c --- /dev/null +++ b/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); + + } +} diff --git a/src/de/jaujau/UnitTests/TEST_Texturenpaket.java b/src/de/jaujau/UnitTests/TEST_Texturenpaket.java new file mode 100755 index 0000000..9dfc6d7 --- /dev/null +++ b/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); + } + } + +} diff --git a/src/de/jaujau/UnitTests/TEST_TexturenpaketIntern.java b/src/de/jaujau/UnitTests/TEST_TexturenpaketIntern.java new file mode 100755 index 0000000..9630ef5 --- /dev/null +++ b/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); + } + } + +} diff --git a/src/de/jaujau/UnitTests/TEST_Texturenpakete.java b/src/de/jaujau/UnitTests/TEST_Texturenpakete.java new file mode 100755 index 0000000..9226772 --- /dev/null +++ b/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); + } + } + +} diff --git a/src/de/jaujau/daten/Ablageort.java b/src/de/jaujau/daten/Ablageort.java index e5fe09e..79aa24a 100755 --- a/src/de/jaujau/daten/Ablageort.java +++ b/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 } diff --git a/src/de/jaujau/daten/Audio.java b/src/de/jaujau/daten/Audio.java new file mode 100644 index 0000000..aafbf11 --- /dev/null +++ b/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(); + } +} diff --git a/src/de/jaujau/daten/Karte.java b/src/de/jaujau/daten/Karte.java index 0c6fafd..72873f5 100644 --- a/src/de/jaujau/daten/Karte.java +++ b/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 + "]"; + } + } diff --git a/src/de/jaujau/daten/Kartensatz.java b/src/de/jaujau/daten/Kartensatz.java index 47d4ed1..6c9c066 100644 --- a/src/de/jaujau/daten/Kartensatz.java +++ b/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 getHand(Spieler spieler) { + ArrayList hand = new ArrayList(); + 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; + } } diff --git a/src/de/jaujau/daten/Spieler.java b/src/de/jaujau/daten/Spieler.java index faaea4d..3e8b4cd 100755 --- a/src/de/jaujau/daten/Spieler.java +++ b/src/de/jaujau/daten/Spieler.java @@ -1,3 +1,10 @@ +/** + + * @author Alaa Aldin + + * @version 1.0 + + */ package de.jaujau.daten; public enum Spieler { diff --git a/src/de/jaujau/daten/Spielerdaten.java b/src/de/jaujau/daten/Spielerdaten.java index f75bc68..88dce4b 100644 --- a/src/de/jaujau/daten/Spielerdaten.java +++ b/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; + } } diff --git a/src/de/jaujau/daten/Spielerverwaltung.java b/src/de/jaujau/daten/Spielerverwaltung.java index b73d583..460d6b1 100644 --- a/src/de/jaujau/daten/Spielerverwaltung.java +++ b/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 () { }; - - // - // Methods - // + private Spielerdaten spieler; - // - // 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; + } } diff --git a/src/de/jaujau/daten/Texturenpaket.java b/src/de/jaujau/daten/Texturenpaket.java new file mode 100755 index 0000000..38347f3 --- /dev/null +++ b/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; + } +} diff --git a/src/de/jaujau/daten/TexturenpaketIntern.java b/src/de/jaujau/daten/TexturenpaketIntern.java new file mode 100755 index 0000000..4af9410 --- /dev/null +++ b/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; + } + +} diff --git a/src/de/jaujau/daten/Texturenpakete.java b/src/de/jaujau/daten/Texturenpakete.java index c8a3c6d..d9a6472 100644 --- a/src/de/jaujau/daten/Texturenpakete.java +++ b/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 TexturenpaketListe; + private BufferedImage Texturen[]; + private int AktivesPaket; + + + public Texturenpakete(){ + TexturenpaketListe = new ArrayList(); + + //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]; + } } diff --git a/src/de/jaujau/gui/Dashboard_GUI.java b/src/de/jaujau/gui/Dashboard_GUI.java new file mode 100644 index 0000000..45b1719 --- /dev/null +++ b/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 comboBox = new JComboBox(); + 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 paketHinzufuegeb()); + contentPane.add(hinzufuegen); + + + //Teste Speichern + speichern = new JButton("Speichern"); + speichern.setBounds(306, 231, 140, 23); + speichern.addActionListener(e-> speichern()); + contentPane.add(speichern); + + + //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))); + } } diff --git a/src/de/jaujau/spiellogik/Anwendung.java b/src/de/jaujau/spiellogik/Anwendung.java index d586ef4..5bd8b69 100644 --- a/src/de/jaujau/spiellogik/Anwendung.java +++ b/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 - // - - - // - // 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 Anwendung() { + speicherung = new Spielerverwaltung(); + texturenpakete = new Texturenpakete(); + view = new GUI(texturenpakete, speicherung); + + + }; /** */ - public void main() - { + public static void main(String[] args) { + /** + * Launch the application. + */ + + Anwendung jaujau = new Anwendung(); + jaujau.view.setVisible(true); } - - -} +} \ No newline at end of file diff --git a/src/de/jaujau/spiellogik/Computer_gegner.java b/src/de/jaujau/spiellogik/Computer_gegner.java index 9e0b849..98d033c 100644 --- a/src/de/jaujau/spiellogik/Computer_gegner.java +++ b/src/de/jaujau/spiellogik/Computer_gegner.java @@ -1,44 +1,279 @@ 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 hand; + private ArrayList 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 */ 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üft ob Farbe der aktuellen Handkarte zur offen liegenden Karte passt + farbeInHand = true; + } + + if(wertHK == letztekartewert) { //Prüft ob Wert der aktuellen Handkarte zur liegenden Karte passt + wertInHand = true; + } + + if(wertHK == Wert.BUBE) { //Prü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ä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ü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ück + * Passen mehrere Karten, gibt sie die letzte passende zurück + * @param Farbe, Farbe zu der eine Karte gesucht wird + * @return integer Index der zurü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ück + * Passen mehrere Karten, gibt sie die letzte passende zurück + * @param Wert, Wert zu dem eine passende Karte gesucht wird + * @return integer Index der zurü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ä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ällige Zahl zwischen 0 und einer andere Zahl r-1 ausgibt + * @param int r + * @return int zufä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ä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ück + */ + public int cpuTest() { + return 1; } - } diff --git a/src/de/jaujau/spiellogik/Spiel.java b/src/de/jaujau/spiellogik/Spiel.java index 98db592..6ae3695 100644 --- a/src/de/jaujau/spiellogik/Spiel.java +++ b/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üge auszuführen, um Kontrollen durchzufü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Ü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ä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ü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); + } } diff --git a/src/de/jaujau/spiellogik/Spielzug.java b/src/de/jaujau/spiellogik/Spielzug.java index 6e4f107..6371778 100644 --- a/src/de/jaujau/spiellogik/Spielzug.java +++ b/src/de/jaujau/spiellogik/Spielzug.java @@ -1,25 +1,97 @@ 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üfen + * @author Moritz Köppe */ 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üft, ob der Spieler eine Karte legen kann, indem jede Karte in der Hand des Spielers mit der Funktion pruefeZug geprü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 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 diff --git a/src/img/exit.png b/src/img/exit.png new file mode 100644 index 0000000..2104464 Binary files /dev/null and b/src/img/exit.png differ diff --git a/src/img/help.png b/src/img/help.png new file mode 100644 index 0000000..6f1ee1c Binary files /dev/null and b/src/img/help.png differ diff --git a/src/img/max.png b/src/img/max.png new file mode 100644 index 0000000..4e96feb Binary files /dev/null and b/src/img/max.png differ diff --git a/src/img/menue.png b/src/img/menue.png new file mode 100644 index 0000000..2230ac3 Binary files /dev/null and b/src/img/menue.png differ diff --git a/src/img/min.png b/src/img/min.png new file mode 100644 index 0000000..ae502e6 Binary files /dev/null and b/src/img/min.png differ diff --git a/src/img/texturen/standart/0.png b/src/img/texturen/standart/0.png new file mode 100755 index 0000000..266a545 Binary files /dev/null and b/src/img/texturen/standart/0.png differ diff --git a/src/img/texturen/standart/1.png b/src/img/texturen/standart/1.png new file mode 100755 index 0000000..103de3f Binary files /dev/null and b/src/img/texturen/standart/1.png differ diff --git a/src/img/texturen/standart/10.png b/src/img/texturen/standart/10.png new file mode 100755 index 0000000..ac9a762 Binary files /dev/null and b/src/img/texturen/standart/10.png differ diff --git a/src/img/texturen/standart/11.png b/src/img/texturen/standart/11.png new file mode 100755 index 0000000..987c6d3 Binary files /dev/null and b/src/img/texturen/standart/11.png differ diff --git a/src/img/texturen/standart/12.png b/src/img/texturen/standart/12.png new file mode 100755 index 0000000..adc2a27 Binary files /dev/null and b/src/img/texturen/standart/12.png differ diff --git a/src/img/texturen/standart/13.png b/src/img/texturen/standart/13.png new file mode 100755 index 0000000..c952223 Binary files /dev/null and b/src/img/texturen/standart/13.png differ diff --git a/src/img/texturen/standart/14.png b/src/img/texturen/standart/14.png new file mode 100755 index 0000000..9bf22b0 Binary files /dev/null and b/src/img/texturen/standart/14.png differ diff --git a/src/img/texturen/standart/15.png b/src/img/texturen/standart/15.png new file mode 100755 index 0000000..84c9475 Binary files /dev/null and b/src/img/texturen/standart/15.png differ diff --git a/src/img/texturen/standart/16.png b/src/img/texturen/standart/16.png new file mode 100755 index 0000000..6d15332 Binary files /dev/null and b/src/img/texturen/standart/16.png differ diff --git a/src/img/texturen/standart/17.png b/src/img/texturen/standart/17.png new file mode 100755 index 0000000..cbddba8 Binary files /dev/null and b/src/img/texturen/standart/17.png differ diff --git a/src/img/texturen/standart/18.png b/src/img/texturen/standart/18.png new file mode 100755 index 0000000..7b93eff Binary files /dev/null and b/src/img/texturen/standart/18.png differ diff --git a/src/img/texturen/standart/19.png b/src/img/texturen/standart/19.png new file mode 100755 index 0000000..43d1bba Binary files /dev/null and b/src/img/texturen/standart/19.png differ diff --git a/src/img/texturen/standart/2.png b/src/img/texturen/standart/2.png new file mode 100755 index 0000000..13c5d11 Binary files /dev/null and b/src/img/texturen/standart/2.png differ diff --git a/src/img/texturen/standart/20.png b/src/img/texturen/standart/20.png new file mode 100755 index 0000000..a2bb12d Binary files /dev/null and b/src/img/texturen/standart/20.png differ diff --git a/src/img/texturen/standart/21.png b/src/img/texturen/standart/21.png new file mode 100755 index 0000000..3793b23 Binary files /dev/null and b/src/img/texturen/standart/21.png differ diff --git a/src/img/texturen/standart/22.png b/src/img/texturen/standart/22.png new file mode 100755 index 0000000..3863fcb Binary files /dev/null and b/src/img/texturen/standart/22.png differ diff --git a/src/img/texturen/standart/23.png b/src/img/texturen/standart/23.png new file mode 100755 index 0000000..9803663 Binary files /dev/null and b/src/img/texturen/standart/23.png differ diff --git a/src/img/texturen/standart/24.png b/src/img/texturen/standart/24.png new file mode 100755 index 0000000..98e46dd Binary files /dev/null and b/src/img/texturen/standart/24.png differ diff --git a/src/img/texturen/standart/25.png b/src/img/texturen/standart/25.png new file mode 100755 index 0000000..efda077 Binary files /dev/null and b/src/img/texturen/standart/25.png differ diff --git a/src/img/texturen/standart/26.png b/src/img/texturen/standart/26.png new file mode 100755 index 0000000..c73bd19 Binary files /dev/null and b/src/img/texturen/standart/26.png differ diff --git a/src/img/texturen/standart/27.png b/src/img/texturen/standart/27.png new file mode 100755 index 0000000..0862be5 Binary files /dev/null and b/src/img/texturen/standart/27.png differ diff --git a/src/img/texturen/standart/28.png b/src/img/texturen/standart/28.png new file mode 100755 index 0000000..b10c1b1 Binary files /dev/null and b/src/img/texturen/standart/28.png differ diff --git a/src/img/texturen/standart/29.png b/src/img/texturen/standart/29.png new file mode 100755 index 0000000..55a6973 Binary files /dev/null and b/src/img/texturen/standart/29.png differ diff --git a/src/img/texturen/standart/3.png b/src/img/texturen/standart/3.png new file mode 100755 index 0000000..2eb5cb4 Binary files /dev/null and b/src/img/texturen/standart/3.png differ diff --git a/src/img/texturen/standart/30.png b/src/img/texturen/standart/30.png new file mode 100755 index 0000000..cbc585e Binary files /dev/null and b/src/img/texturen/standart/30.png differ diff --git a/src/img/texturen/standart/31.png b/src/img/texturen/standart/31.png new file mode 100755 index 0000000..887b152 Binary files /dev/null and b/src/img/texturen/standart/31.png differ diff --git a/src/img/texturen/standart/32.png b/src/img/texturen/standart/32.png new file mode 100755 index 0000000..95e2106 Binary files /dev/null and b/src/img/texturen/standart/32.png differ diff --git a/src/img/texturen/standart/4.png b/src/img/texturen/standart/4.png new file mode 100755 index 0000000..63fa650 Binary files /dev/null and b/src/img/texturen/standart/4.png differ diff --git a/src/img/texturen/standart/5.png b/src/img/texturen/standart/5.png new file mode 100755 index 0000000..3cc6c95 Binary files /dev/null and b/src/img/texturen/standart/5.png differ diff --git a/src/img/texturen/standart/6.png b/src/img/texturen/standart/6.png new file mode 100755 index 0000000..0c85319 Binary files /dev/null and b/src/img/texturen/standart/6.png differ diff --git a/src/img/texturen/standart/7.png b/src/img/texturen/standart/7.png new file mode 100755 index 0000000..3f9cf96 Binary files /dev/null and b/src/img/texturen/standart/7.png differ diff --git a/src/img/texturen/standart/8.png b/src/img/texturen/standart/8.png new file mode 100755 index 0000000..75aa27c Binary files /dev/null and b/src/img/texturen/standart/8.png differ diff --git a/src/img/texturen/standart/9.png b/src/img/texturen/standart/9.png new file mode 100755 index 0000000..ff3332d Binary files /dev/null and b/src/img/texturen/standart/9.png differ diff --git a/src/sound/jau.wav b/src/sound/jau.wav new file mode 100644 index 0000000..fb15ccf Binary files /dev/null and b/src/sound/jau.wav differ diff --git a/src/sound/jaujau.wav b/src/sound/jaujau.wav new file mode 100644 index 0000000..3a6ee05 Binary files /dev/null and b/src/sound/jaujau.wav differ