diff --git a/.DS_Store b/.DS_Store index 48d84d1..d111a3b 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/.gitignore b/.gitignore index 4ccb9be..d734042 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,5 @@ # Jar dateien /lib .idea +/Main.class +/RendomTest.class diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..335f886 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "editor.defaultFormatter": "esbenp.prettier-vscode" +} \ No newline at end of file diff --git a/Bild 2.jpeg b/Bild 2.jpeg new file mode 100644 index 0000000..b8407cb Binary files /dev/null and b/Bild 2.jpeg differ diff --git a/Bild.jpeg b/Bild.jpeg new file mode 100644 index 0000000..fea643d Binary files /dev/null and b/Bild.jpeg differ diff --git a/Domain/Enums/Kartenfarbe.java b/Domain/Enums/Kartenfarbe.java index 5a9f882..effb082 100644 --- a/Domain/Enums/Kartenfarbe.java +++ b/Domain/Enums/Kartenfarbe.java @@ -9,15 +9,20 @@ package Domain.Enums; public enum Kartenfarbe { MENSCH("BLAU"), ZWERG("ROT"), ELF("GRÜN"), RIESE("GELB"); - + private String farbe; - - private Kartenfarbe (String farbe) { + + private Kartenfarbe(String farbe) { this.farbe = farbe; } - + public String getFarbe() { return farbe; } + @Override + public String toString() { + return getFarbe(); + } + } diff --git a/Domain/Exceptions/EmptyListException.java b/Domain/Exceptions/EmptyListException.java new file mode 100644 index 0000000..c3f929a --- /dev/null +++ b/Domain/Exceptions/EmptyListException.java @@ -0,0 +1,13 @@ +/* +============================================================ +This is the "EmptyListException" file from Author: Philipp Kotte +written on: 16 / 10 / 2023 at: 07:54 +============================================================ +*/ +package Domain.Exceptions; + +public class EmptyListException extends SpielException { + public EmptyListException(String message) { + super(10, message); + } +} diff --git a/Domain/Exceptions/SpielException.java b/Domain/Exceptions/SpielException.java new file mode 100644 index 0000000..2029354 --- /dev/null +++ b/Domain/Exceptions/SpielException.java @@ -0,0 +1,65 @@ +/* +============================================================ +This is the "SpielException" file from Author: Philipp Kotte +written on: 16 / 10 / 2023 at: 07:42 +============================================================ +*/ +package Domain.Exceptions; + +public abstract class SpielException extends Exception { + /*------------------------------------------*/ + // statische Konstanten + /*------------------------------------------*/ + + /*------------------------------------------*/ + // statische Attribute(zB. zähler) + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Attribute jedes Objektes + /*------------------------------------------*/ + private String message; + private int id; + + /*------------------------------------------*/ + // Konstruktoren (default und spezifische) + /*------------------------------------------*/ + public SpielException() { + } + + public SpielException(int id, String message) { + + } + + public SpielException(String message) { + + } + + /*------------------------------------------*/ + // statische Methoden + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Getter und Setter + /*------------------------------------------*/ + + /*------------------------------------------*/ + // @Overrides + /*------------------------------------------*/ + + public String getMessage() { + return this.message; + } + + public int getID() { + return this.id; + } + + /*------------------------------------------*/ + // öffentliche Methodes + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Hilfsmethoden (privat) + /*------------------------------------------*/ +} diff --git a/Domain/Exceptions/SpielerNotFoundException.java b/Domain/Exceptions/SpielerNotFoundException.java new file mode 100644 index 0000000..a3346f6 --- /dev/null +++ b/Domain/Exceptions/SpielerNotFoundException.java @@ -0,0 +1,15 @@ +/* +============================================================ +This is the "SpielerNotFoundException" file from Author: Philipp Kotte +written on: 16 / 10 / 2023 at: 07:50 +============================================================ +*/ +package Domain.Exceptions; + +public class SpielerNotFoundException extends SpielException { + + public SpielerNotFoundException(String message) { + super(1, message); + } + +} diff --git a/Domain/Karten/Karte.java b/Domain/Karten/Karte.java index 0e5b203..8144eea 100644 --- a/Domain/Karten/Karte.java +++ b/Domain/Karten/Karte.java @@ -9,28 +9,31 @@ package Domain.Karten; public abstract class Karte { // Statische Konstanten - + // Statische Attribute - private static int id_card = 0; + private int id; // Attribute des Ojektes - - + // Konstruktoren public Karte() { - if (id_card < 60) { - id_card++; - } + } + + public Karte(int id) { + this.id = id; + } + // Statische Methoden - public static int getId_card() { - return id_card; - } + // Getter und Setter - - + + public int getId() { + return this.id; + } + // @Overrides - + // Public Methoden (öffentliche Methoden) - + // Private Methoden (Hilfsmethoden) } diff --git a/Domain/Karten/Magierkarte.java b/Domain/Karten/Magierkarte.java index bbd551f..d9d4bf9 100644 --- a/Domain/Karten/Magierkarte.java +++ b/Domain/Karten/Magierkarte.java @@ -10,49 +10,46 @@ import Domain.Enums.Kartenfarbe; public class Magierkarte extends Karte { - // Statische Konstanten - + private final static String NAME = "Zauberer"; // Statische Attribute - + // Attribute des Objekts - private Kartenfarbe farbe; - private String bezeichnung; + + private String name; + // Konstruktoren - - public Magierkarte() { - super(); + + public Magierkarte(int id) { + super(id); + setName(); + } - - public Magierkarte(Kartenfarbe farbe, String bezeichnung) { - super(); - setFarbe(farbe); - setBezeichnung(bezeichnung); - } - + // Statische Methoden - + // Getter und Setter - - public void setFarbe(Kartenfarbe farbe) { - this.farbe = farbe; - } - public Kartenfarbe getFarbe() { - return this.farbe; - } + public int getId() { - return Karte.getId_card(); + return super.getId(); } - public void setBezeichnung(String bezeichnung) { - this.bezeichnung = bezeichnung; + + private void setName() { + this.name = NAME; } - public String getBezeichnung () { - return this.bezeichnung; + + public String getName() { + return this.name; } + + // @Overrides - + @Override + public String toString() { + return "ID " + this.getId() + ": " + this.getName(); + } // Public Methoden - + // Private Methoden - + } diff --git a/Domain/Karten/Narrenkarte.java b/Domain/Karten/Narrenkarte.java index 293ebbd..7b081e6 100644 --- a/Domain/Karten/Narrenkarte.java +++ b/Domain/Karten/Narrenkarte.java @@ -11,47 +11,46 @@ import Domain.Enums.Kartenfarbe; public class Narrenkarte extends Karte { // Statische Konstanten - + private final static String NAME = "Narr"; // Statische Attribute - + // Attribute des Objekts - private Kartenfarbe farbe; - private String bezeichnung; + + private String name; // Konstruktoren - - public Narrenkarte() { - super(); - } - - public Narrenkarte(Kartenfarbe farbe, String bezeichnung) { - super(); - setFarbe(farbe); - setBezeichnung(bezeichnung); + + public Narrenkarte(int id) { + super(id); + setName(); + } // Statische Methoden - + // Getter und Setter + public int getId() { - return Karte.getId_card(); + return super.getId(); } - - public void setFarbe(Kartenfarbe farbe) { - this.farbe = farbe; + + private void setName() { + this.name = NAME; } - public Kartenfarbe getFarbe() { - return this.farbe; + + public String getName() { + return this.name; } - - public void setBezeichnung(String bezeichnung) { - this.bezeichnung = bezeichnung; - } - public String getBezeichnung() { - return this.bezeichnung; + + public void setNarrenkarteanzahl(int narrenkarteanzahl) { + narrenkarteanzahl++; } + // @Overrides - + @Override + public String toString() { + return "ID " + this.getId() + ": " + this.getName(); + } // Public Methoden - + // Private Methoden - + } diff --git a/Domain/Karten/Zahlenkarte.java b/Domain/Karten/Zahlenkarte.java index 9f52db5..3959ece 100644 --- a/Domain/Karten/Zahlenkarte.java +++ b/Domain/Karten/Zahlenkarte.java @@ -6,42 +6,75 @@ written on: 05 / 10 / 2023 at: 23:30 */ package Domain.Karten; +import Domain.Enums.Kartenfarbe; + public class Zahlenkarte extends Karte { - /*------------------------------------------*/ - // statische Konstanten - /*------------------------------------------*/ + /*------------------------------------------*/ + // statische Konstanten + /*------------------------------------------*/ - /*------------------------------------------*/ - // statische Attribute(zB. zähler) - /*------------------------------------------*/ + /*------------------------------------------*/ + // statische Attribute(zB. zähler) + /*------------------------------------------*/ - /*------------------------------------------*/ - // Attribute jedes Objektes - /*------------------------------------------*/ + /*------------------------------------------*/ + // Attribute jedes Objektes + /*------------------------------------------*/ + private Kartenfarbe farbe; + private int kartenNummer; - /*------------------------------------------*/ - // Konstruktoren (default und spezifische) - /*------------------------------------------*/ + /*------------------------------------------*/ + // Konstruktoren (default und spezifische) + /*------------------------------------------*/ + public Zahlenkarte(int id) { + super(id); + } - /*------------------------------------------*/ - // statische Methoden - /*------------------------------------------*/ + public Zahlenkarte(int id, Kartenfarbe farbe, int kartenNummer) { + super(id); + setFarbe(farbe); + setKartenNummer(kartenNummer); - /*------------------------------------------*/ - // Getter und Setter - /*------------------------------------------*/ + } + /*------------------------------------------*/ + // statische Methoden + /*------------------------------------------*/ - /*------------------------------------------*/ - // @Overrides - /*------------------------------------------*/ + /*------------------------------------------*/ + // Getter und Setter + /*------------------------------------------*/ + + public int getId() { + return super.getId(); + } + + public void setFarbe(Kartenfarbe farbe) { + this.farbe = farbe; + } - /*------------------------------------------*/ - // öffentliche Methodes - /*------------------------------------------*/ + public Kartenfarbe getFarbe() { + return farbe; + } - /*------------------------------------------*/ - // Hilfsmethoden (privat) - /*------------------------------------------*/ + public void setKartenNummer(int kartenNummer) { + this.kartenNummer = kartenNummer; + } -} + public int getKartenNummer() { + return kartenNummer; + } + + /*------------------------------------------*/ + // @Overrides + /*------------------------------------------*/ + + /*------------------------------------------*/ + // öffentliche Methodes + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Hilfsmethoden (privat) + /*------------------------------------------*/ + +} \ No newline at end of file diff --git a/Domain/Kartenstapel.java b/Domain/Kartenstapel.java index 1851498..a99684f 100644 --- a/Domain/Kartenstapel.java +++ b/Domain/Kartenstapel.java @@ -6,74 +6,142 @@ written on: 05 / 10 / 2023 at: 23:42 */ package Domain; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Random; +import java.util.HashMap; +import Domain.Enums.Kartenfarbe; import Domain.Karten.*; + public class Kartenstapel { - /*------------------------------------------*/ - // statische Konstanten - /*------------------------------------------*/ + // Statische Konstanten - /*------------------------------------------*/ - // statische Attribute(zB. zähler) - /*------------------------------------------*/ + // Statische Attribute + private static int kartenzählen = 1; + // Attribute der Objekte + + /** + * Die HashMap besitzt alle Karten in sortierter Reihenfolge Die ArrayList wird + * durch Zufall erzeugt und gibt den Key der HashMap wieder. D.h. + */ + private HashMap kartensortiert = new HashMap<>(); - /*------------------------------------------*/ - // Attribute jedes Objektes - /*------------------------------------------*/ - - private Karte[] kartenStapel = new Karte[60]; - - /*------------------------------------------*/ - // Konstruktoren (default und spezifische) - /*------------------------------------------*/ + private HashMap kartengemischt = new HashMap<>(); + // Konstruktoren public Kartenstapel() { + kartensortiert.clear(); + // Erstelle Magierkarten + for (int i = 1; i <= 4; i++) { + kartensortiert.put(i, new Magierkarte(i)); + } + // Erstelle Narrenkarten + for (int i = 5; i <= 8; i++) { + kartensortiert.put(i, new Narrenkarte(i)); + } + // Erstelle Charakterkarten MENSCH + for (int i = 9; i <= 21; i++) { + kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8)); + } + // Erstelle Charakterkarten ELF + for (int i = 22; i <= 34; i++) { + kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ELF, i - 21)); + } + // Erstelle Charakterkarten RIESE + for (int i = 35; i <= 47; i++) { + kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.RIESE, i - 34)); + } + // Erstelle Charakterkarten ZWERG + for (int i = 48; i <= 60; i++) { + kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47)); + } + } + // Statische Methoden - /*------------------------------------------*/ - // statische Methoden - /*------------------------------------------*/ - - /*------------------------------------------*/ // Getter und Setter - /*------------------------------------------*/ + public Karte getKartesortiert(Integer index) { + return kartensortiert.get(index); + } + // Overrides + // Public Methoden /** - * Ausgabe des ersten Elements des Stapels. + * Die Collection der HashMap 'kartensortiert'. * - * @return erstes Element + * @return Die Kartenreferenzen der HashMap. */ - public Karte getObersteKarte() { - return kartenStapel[0]; + public Collection getKartenstapelSortiert() { + return kartensortiert.values(); + } + + public Collection getKartenstapelGemischt() { + return kartengemischt.values(); } /** - * Ausgabe der Stapelgroesse. + * Methode für die Testklasse KartenstapelTest, um die Sortierung Visuell zu + * bestätigen. Kann nach Finalem Test und Freigabe gelöscht oder auskommentiert + * werden. * - * @return laenge des Kartenstapels-Arrays + * @return 'kg' Eine Namensliste des gemischten Kartenstapel */ - public int getAnzahlKarten() { - return kartenStapel.length; + public HashMap getStatusGemischt() { + HashMap kg = new HashMap<>(); + for (int i = 1; i <= 60; i++) { + kg.put(i, ((String) kartengemischt.get(i).toString())); + } + return kg; } - /*------------------------------------------*/ - // @Overrides - /*------------------------------------------*/ - - /*------------------------------------------*/ - // öffentliche Methoden - /*------------------------------------------*/ - + /** + * Methode mischen(): beinhaltet eine ArrayList 'zahlen' die Zahlenwerte von 1 + * bis 60 zur Verfügung stellt. + * + * @code Mit Random wird ein Zufallsindex gewählt. 'kartensortiert' und + * 'kartengemsicht' sind zwei HashMap. 'kartensortiert' beinhaltet alle + * Karten in einer initialisierten Reihenfolge. 'kartengemischt' wird + * durch die @code Random 'zufall' befüllt. + * + */ public void mischen() { - + ArrayList zahlen = new ArrayList<>(); + for (int i = 1; i <= 60; i++) { + zahlen.add(i); + } + Random zufall = new Random(); + for (int i = 0; i < 60; i++) { + int index = zufall.nextInt(zahlen.size()); + int schlüsselzahl = zahlen.get(index); + kartengemischt.put(i + 1, kartensortiert.get(schlüsselzahl)); + zahlen.remove(index); + } + + for(Karte k : kartengemischt.values()) { + System.out.println(k.toString()); + } } - /*------------------------------------------*/ - // Hilfsmethoden (privat) - /*------------------------------------------*/ - - // + /** + * Methode getObersteKarte(): Hier wird der Reihe nach die jeweils oberste Karte + * an den Spieler verteilt, bzw. am Ende des Verteilens der Trumpf gezogen, + * falls noch eine Karte auf dem Stapel liegen sollte. Hierzu wird die Runde, + * als Ausgangswert genommen. + */ + public Object getObersteKarte() { + Object k = kartengemischt.values().toArray()[0]; + kartengemischt.remove(k); + return k; + } + + + /** + * + */ + // Private Methoden } diff --git a/Domain/Spieler.java b/Domain/Spieler.java index e01e2d7..972fe85 100644 --- a/Domain/Spieler.java +++ b/Domain/Spieler.java @@ -10,7 +10,7 @@ import Domain.Enums.Geschlecht; import java.io.Serializable; -public class Spieler implements Serializable { +public class Spieler extends Object implements Serializable { /*------------------------------------------*/ // statische Konstanten @@ -23,10 +23,11 @@ public class Spieler implements Serializable { /*------------------------------------------*/ // Attribute jedes Objektes /*------------------------------------------*/ - private int id; + private int id = 0; private String name; private int vorhersage; private Geschlecht geschlecht; + // /*------------------------------------------*/ // Konstruktoren (default und spezifische) @@ -48,8 +49,18 @@ public class Spieler implements Serializable { */ public Spieler(int id, String name, Geschlecht geschlecht) { this(); - setId(id); - setName(name); + if (id < 6) { + setId(id); + } else { + throw new RuntimeException("Es darf nur max 6 Spieler geben."); + } + if (geschlecht == Geschlecht.KI) { + setName(name); // Bei KI wird kein Name gesetzt. name = leerer String + } else if (name.length() > 2) { + setName(name); // Es wird geprüft, ob Name größer 2 Zeichen + } else { + throw new RuntimeException("Der Name muss länger als 2 Buchstaben sein."); + } setGeschlecht(geschlecht); } @@ -109,7 +120,7 @@ public class Spieler implements Serializable { * @return String name */ public String getName() { - return name; + return this.name; } // geschlecht diff --git a/Domain/Stich.java b/Domain/Stich.java new file mode 100644 index 0000000..9f61878 --- /dev/null +++ b/Domain/Stich.java @@ -0,0 +1,82 @@ +/* +============================================================ +This is the "Stich" file from Author: Philipp Kotte +written on: 11 / 10 / 2023 at: 20:25 +============================================================ +*/ +package Domain; + +import Domain.Karten.Karte; + +public class Stich { + /*------------------------------------------*/ + // statische Konstanten + /*------------------------------------------*/ + + /*------------------------------------------*/ + // statische Attribute(zB. zähler) + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Attribute jedes Objektes + /*------------------------------------------*/ + private Karte[] karten; + private int[] spielerID; + private int kartenCount = 0; + /*------------------------------------------*/ + // Konstruktoren (default und spezifische) + /*------------------------------------------*/ + + public Stich() { + } + + public Stich(int spielerAnzahl) { + setSpielerAnzahl(spielerAnzahl); + } + + /*------------------------------------------*/ + // statische Methoden + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Getter und Setter + /*------------------------------------------*/ + + public void setSpielerAnzahl(int spielerAnzahl) { + this.karten = new Karte[spielerAnzahl]; + this.spielerID = new int[spielerAnzahl]; + } + + public Karte[] getKarten() { + return this.karten; + } + + public void addKarte(int spielerID, Karte karte) { + this.karten[kartenCount] = karte; + this.spielerID[kartenCount] = spielerID; + kartenCount++; + } + + /*------------------------------------------*/ + // @Overrides + /*------------------------------------------*/ + + @Override + public String toString() { + String text = ""; + for (int i = 0; i < this.karten.length; i++) { + text += this.karten[i].toString(); + } + + return text; + } + + /*------------------------------------------*/ + // öffentliche Methodes + /*------------------------------------------*/ + + /*------------------------------------------*/ + // Hilfsmethoden (privat) + /*------------------------------------------*/ + +} diff --git a/Facade/Spiel.java b/Facade/Spiel.java index 3925d13..70a8e31 100644 --- a/Facade/Spiel.java +++ b/Facade/Spiel.java @@ -11,8 +11,12 @@ import java.util.HashMap; import Domain.Kartenstapel; import Domain.Spieler; +import Domain.Stich; import Domain.Block.Block; import Domain.Enums.Geschlecht; +import Domain.Exceptions.EmptyListException; +import Domain.Exceptions.SpielerNotFoundException; +import Domain.Karten.Karte; public class Spiel implements Serializable { @@ -20,6 +24,11 @@ public class Spiel implements Serializable { // statische Konstanten /*--------------------------------------------------------*/ + private static final String ANSI_RESET = "\u001B[0m"; + private static final String ANSI_GREEN = "\u001B[32m"; + private static final String ANSI_RED = "\u001B[31m"; + public static final String ANSI_BLUE = "\u001B[34m"; + /*--------------------------------------------------------*/ // statische Attribute(zB. zähler) /*--------------------------------------------------------*/ @@ -33,6 +42,7 @@ public class Spiel implements Serializable { private Spieler spielerAmZug; private int runde; private HashMap spieler = new HashMap<>(); + private HashMap stiche = new HashMap<>(); private boolean[] id_check = { false, false, false, false, false, false }; private Kartenstapel kartenstapel; private Block block; @@ -46,6 +56,7 @@ public class Spiel implements Serializable { this.istBeendet = false; this.spielerAmZug = null; this.runde = 0; + this.kartenstapel = new Kartenstapel(); }; /*--------------------------------------------------------*/ // statische Methoden @@ -77,8 +88,34 @@ public class Spiel implements Serializable { @Override public String toString() { - return "Runde: " + getRunde() + ", Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + ", Beendet: " - + (istSpielBeendet() ? "Ja" : "Nein") + ", Spieler am Zug: " + getSpielerAmZug()[0]; + String text = "\n"; + String header = "Systemausgabe--------------------------------\n"; + String footer = "---------------------------------------------\n"; + text += header; + text += "Runde: " + getRunde() + "\n"; + text += "Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + "\n"; + text += "Beendet: " + (istSpielBeendet() ? "Ja" : "Nein") + "\n"; + text += "Spieler am Zug: " + + (this.spielerAmZug == null ? "Noch keine Spieler vorhanden" : this.spielerAmZug.getName()) + "\n"; + if (this.spieler.size() == 0) { + text += "Noch keine Spieler vorhanden \n"; + } else { + for (Spieler s : this.spieler.values()) { + text += "[" + s.getId() + "] " + s.getName() + " (" + + s.getGeschlecht() + ")" + "\n"; + + } + } + for (int i = 0; i < this.id_check.length; i++) { + if (this.id_check[i]) { + text += "idcheck" + ANSI_BLUE + " [" + i + "] " + ANSI_GREEN + this.id_check[i] + ANSI_RESET + " \n"; + } else { + text += "idcheck" + ANSI_BLUE + " [" + i + "] " + ANSI_RED + this.id_check[i] + ANSI_RESET + " \n"; + } + + } + text += footer; + return text; } /*--------------------------------------------------------*/ @@ -90,25 +127,69 @@ public class Spiel implements Serializable { while (id_check[id - 1]) { id++; } + id_check[id - 1] = true; Spieler temp = new Spieler(id, name, geschlecht); this.spieler.put(id, temp); + System.out.println(this.spieler.get(id)); + if (this.spielerAmZug == null) { + this.spielerAmZug = temp; + } + updateSpielerAmZug(); } - public void removeSpieler(int id_spieler) { - this.spieler.remove(id_spieler); + public void removeSpieler(int id_spieler) throws SpielerNotFoundException, EmptyListException, RuntimeException { + if (this.spieler.containsKey(id_spieler)) { + this.spieler.remove(id_spieler); + this.id_check[id_spieler - 1] = false; + } else if (!this.spieler.containsKey(id_spieler)) { + throw new SpielerNotFoundException("Dieser Spieler existiert nicht"); + } else if (this.spieler.values().size() == 0) { + throw new EmptyListException("Dise Liste ist Leer."); + } else { + throw new RuntimeException("Unkown Error"); + } + updateSpielerAmZug(); } public String[] getAlleSpieler() { String[] spieler_text = new String[this.spieler.size()]; - for (int i = 0; i < this.spieler.size() - 1; i++) { - spieler_text[i] = this.spieler.get(i).toString(); + int zähler = 0; + for (Spieler s : this.spieler.values()) { + spieler_text[zähler] = s.toString(); + zähler++; } return spieler_text; } public void starteSpiel() { - this.istGestartet = true; - // Gameloop? + // sing genügend Spieler angelegt? + if (this.spieler.size() >= 3 && this.spieler.size() <= 6) { + this.istGestartet = true; + while (!this.istSpielBeendet()) { + System.out.println("Das Spiel wurde gestartet."); + + // Beginn der Runde + // Stiche erstellen + erstelleStiche(this.runde); + // Karten für jeden Spieler verteilen + + // While loop mit der länge der anzahl Stiche für die jeweilige Runde + + // Für jeden Durchgang des Loops wird der Stich ermittelt + + // Wer gewonnen hat wird dann der Stich zugeordnet + + // prüfen ob das Spiel zuende ist + + // Der Spieler der jetzt am Zug ist, ist der der den letzten Stich gewonne hat + + // Runde erhöhen + runde++; + } + } else { + System.out.println("Es fehlen " + (3 - this.spieler.size()) + " spieler"); + } + } public String[] getSpielerAmZug() { @@ -141,6 +222,13 @@ public class Spiel implements Serializable { public void austeilen() { + // Spieler 1 bekommt karten + + // Spieler 2 bekommt Karten + // ... + + // letzer Spieler bekommt Karten + } public void ausspielen(int idKarte) { @@ -155,4 +243,22 @@ public class Spiel implements Serializable { // Hilfsmethoden (privat) /*--------------------------------------------------------*/ + private void erstelleStiche(int runde) { + for (int i = 0; i < runde; i++) { + this.stiche.put(i + 1, new Stich(this.spieler.size())); + } + } + + private void ermittleGewinner(Stich stich) { + stich.getKarten(); + } + + private void updateSpielerAmZug() { + if (this.spieler.size() >= 1) { + this.spielerAmZug = (Spieler) this.spieler.values().toArray()[0]; + } else { + this.spielerAmZug = null; + } + } + } \ No newline at end of file diff --git a/RendomTest.java b/RendomTest.java new file mode 100644 index 0000000..d6603f1 --- /dev/null +++ b/RendomTest.java @@ -0,0 +1,29 @@ +/* +============================================================ +This is the "RendomTest" file from Author: Philipp Kotte +written on: 20 / 10 / 2023 at: 08:26 +============================================================ +*/ + +import java.util.Random; + +public class RendomTest { + + // ----------------------------- Spiel + // ausspiele(int Kartenid){ + // Karte temp = Spieler.getKarte(id) + // Stich.add(spielerAmZug.getId(), temp); + // } + + // ------------------------------Stich + // Trumpf: Mensch + // spielerID: [3, 4, 1, 2] + // Karten: [Zwerg 4, Magier, narr, Magie] + // + // wo sind magier, false, true + // Karte -> Karten[1] + // Spieler -> spielerID[1] + // + // private void add(int Spielerid, int Kartenid){} + // spieler +} diff --git a/Test/Domain/Karten/MagierkarteTest.java b/Test/Domain/Karten/MagierkarteTest.java index 53003d6..640ee05 100644 --- a/Test/Domain/Karten/MagierkarteTest.java +++ b/Test/Domain/Karten/MagierkarteTest.java @@ -6,6 +6,35 @@ written on: 10 / 10 / 2023 at: 21:18 */ package Test.Domain.Karten; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import Domain.Karten.Magierkarte; + + public class MagierkarteTest { + + @Test + public void vierMagier() { + Magierkarte m1 = new Magierkarte(1); + Magierkarte m2 = new Magierkarte(2); + Magierkarte m3 = new Magierkarte(3); + Magierkarte m4 = new Magierkarte(4); + + + assertEquals("Zauberer", m1.getName()); + assertTrue(1 == m1.getId()); + assertEquals("Zauberer", m2.getName()); + assertTrue(2 == m2.getId()); + assertEquals("Zauberer", m3.getName()); + assertTrue(3 == m3.getId()); + assertEquals("Zauberer", m4.getName()); + assertTrue(4 == m4.getId()); + + assertEquals("ID 1: Zauberer", m1.toString()); + + } + } diff --git a/Test/Domain/Karten/NarrenkarteTest.java b/Test/Domain/Karten/NarrenkarteTest.java index dfc5fab..bbfae08 100644 --- a/Test/Domain/Karten/NarrenkarteTest.java +++ b/Test/Domain/Karten/NarrenkarteTest.java @@ -6,6 +6,34 @@ written on: 10 / 10 / 2023 at: 21:18 */ package Test.Domain.Karten; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import Domain.Karten.Narrenkarte; + public class NarrenkarteTest { + + @Test + public void vierNarren() { + Narrenkarte n1 = new Narrenkarte(5); + Narrenkarte n2 = new Narrenkarte(6); + Narrenkarte n3 = new Narrenkarte(7); + Narrenkarte n4 = new Narrenkarte(8); + + assertEquals(n1.getName(), "Narr"); + assertTrue(5 == n1.getId()); + assertEquals(n2.getName(), "Narr"); + assertTrue(6 == n2.getId()); + assertEquals(n3.getName(), "Narr"); + assertTrue(7 == n3.getId()); + assertEquals(n4.getName(), "Narr"); + assertTrue(8 == n4.getId()); + + assertEquals("ID 5: Narr", n1.toString()); + + + } } diff --git a/Test/Domain/Karten/ZahlenkarteTest.java b/Test/Domain/Karten/ZahlenkarteTest.java index ebbc270..612a9ab 100644 --- a/Test/Domain/Karten/ZahlenkarteTest.java +++ b/Test/Domain/Karten/ZahlenkarteTest.java @@ -6,6 +6,82 @@ written on: 10 / 10 / 2023 at: 21:18 */ package Test.Domain.Karten; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.HashMap; + +import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; + +import Domain.Enums.Kartenfarbe; +import Domain.Karten.Karte; +import Domain.Karten.Zahlenkarte; + public class ZahlenkarteTest { + + @Test + public void zahlenkartentesten() { + + HashMap zk = new HashMap<>(); + + for (int i = 1; i <= 8; i++) { + zk.put(i, null); + } + + for (int i = 9; i <= 21; i++) { + zk.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8)); + } + for (int i = 22; i <= 34; i++) { + zk.put(i, new Zahlenkarte(i, Kartenfarbe.ELF, i - 21)); + } + for (int i = 35; i <= 47; i++) { + zk.put(i, new Zahlenkarte(i, Kartenfarbe.RIESE, i - 34)); + } + for (int i = 48; i <= 60; i++) { + zk.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47)); + } + + // Testen der Charakterkarten MENSCH + assertEquals(1, ((Zahlenkarte) zk.get(9)).getKartenNummer()); + assertEquals(13, ((Zahlenkarte) zk.get(21)).getKartenNummer()); + assertEquals(5, ((Zahlenkarte) zk.get(13)).getKartenNummer()); + + assertEquals(17, ((Zahlenkarte) zk.get(17)).getId()); + + assertTrue(Kartenfarbe.MENSCH == ((Zahlenkarte) zk.get(17)).getFarbe()); + + // Testen der Charakterkarten ELF + assertEquals(1, ((Zahlenkarte) zk.get(22)).getKartenNummer()); + assertEquals(13, ((Zahlenkarte) zk.get(34)).getKartenNummer()); + assertEquals(11, ((Zahlenkarte) zk.get(32)).getKartenNummer()); + + assertEquals(28, ((Zahlenkarte) zk.get(28)).getId()); + + assertTrue(Kartenfarbe.ELF == ((Zahlenkarte) zk.get(28)).getFarbe()); + + // Testen der Charakterkarten RIESE + assertEquals(1, ((Zahlenkarte) zk.get(35)).getKartenNummer()); + assertEquals(13, ((Zahlenkarte) zk.get(47)).getKartenNummer()); + assertEquals(3, ((Zahlenkarte) zk.get(37)).getKartenNummer()); + + assertEquals(41, ((Zahlenkarte) zk.get(41)).getId()); + + assertTrue(Kartenfarbe.RIESE == ((Zahlenkarte) zk.get(41)).getFarbe()); + + // Testen der Charakterkarten ZWERG + assertEquals(1, ((Zahlenkarte) zk.get(48)).getKartenNummer()); + assertEquals(13, ((Zahlenkarte) zk.get(60)).getKartenNummer()); + assertEquals(6, ((Zahlenkarte) zk.get(53)).getKartenNummer()); + + assertEquals(53, ((Zahlenkarte) zk.get(53)).getId()); + + assertTrue(Kartenfarbe.ZWERG == ((Zahlenkarte) zk.get(53)).getFarbe()); + + + + } + + } diff --git a/Test/Domain/KartenstapelTest.java b/Test/Domain/KartenstapelTest.java index 15de398..72919fc 100644 --- a/Test/Domain/KartenstapelTest.java +++ b/Test/Domain/KartenstapelTest.java @@ -8,8 +8,6 @@ package Test.Domain; import org.junit.Test; -import static org.junit.Assert.assertEquals; - public class KartenstapelTest { @Test diff --git a/Test/Domain/SpielerTest.java b/Test/Domain/SpielerTest.java index d346317..ee93bde 100644 --- a/Test/Domain/SpielerTest.java +++ b/Test/Domain/SpielerTest.java @@ -12,18 +12,25 @@ import Domain.Spieler; import Domain.Enums.Geschlecht; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; public class SpielerTest { Spieler spieler = new Spieler(0, "Herbert", Geschlecht.M, 0); Spieler spieler2 = new Spieler(1, "Heinz", Geschlecht.M, 0); Spieler spieler3 = new Spieler(2, "Ulrike", Geschlecht.W, 0); + Spieler spieler4 = new Spieler(3, "HerrFrau", Geschlecht.D, 0); + Spieler spieler5 = new Spieler(4, "", Geschlecht.KI, 0); + Spieler spieler6 = new Spieler(5, "", Geschlecht.KI, 0); @Test public void idTest() { assertEquals(0, spieler.getId()); assertEquals(1, spieler2.getId()); assertEquals(2, spieler3.getId()); + assertEquals(3, spieler4.getId()); + assertEquals(4, spieler5.getId()); + assertEquals(5, spieler6.getId()); } @Test @@ -42,6 +49,11 @@ public class SpielerTest { assertEquals("Herbert", spieler.getName()); spieler.setName("Heinz"); assertEquals("Heinz", spieler.getName()); + assertEquals("", spieler5.getName()); //Kein Name notwendig, da KI. } + @Test + public void exceptionsTest() { + assertThrows(RuntimeException.class, () -> new Spieler(6, "", Geschlecht.KI, 0)); + } } diff --git a/UI/SpielCLI.java b/UI/SpielCLI.java index d1cb015..6123a62 100644 --- a/UI/SpielCLI.java +++ b/UI/SpielCLI.java @@ -8,11 +8,20 @@ written on: 05 / 10 / 2023 at: 23:25 package UI; import Facade.Spiel; +import Domain.Spieler; +import Domain.Enums.Geschlecht; +import Domain.Exceptions.EmptyListException; +import Domain.Exceptions.SpielerNotFoundException; import java.util.Scanner; public class SpielCLI { + private static final String ANSI_RESET = "\u001B[0m"; + private static final String ANSI_GREEN = "\u001B[32m"; + private static final String ANSI_RED = "\u001B[31m"; + public static final String ANSI_BLUE = "\u001B[34m"; + Scanner sc = new Scanner(System.in); private Spiel spiel; @@ -22,13 +31,15 @@ public class SpielCLI { } public void hauptmenue() { + System.out.println("Hallo Wanderer"); mainloop: while (true) { - System.out.println("Hallo Wanderer"); - System.out.println("Was sillst du tun"); - System.out.println("--------Hauptmenü--------"); - System.out.println("-1- Spiel starten"); - System.out.println("-2- Spiel to String"); - System.out.println("-3- Exit"); + print(""); + print("--------Hauptmenü--------"); + print(ANSI_BLUE + "-1-" + ANSI_RESET + " Spiel starten"); + print(ANSI_BLUE + "-2-" + ANSI_RESET + " Spieler hinzufügen"); + print(ANSI_BLUE + "-3-" + ANSI_RESET + " Spiel to String"); + print(ANSI_BLUE + "-4-" + ANSI_RESET + " Spieler löschen"); + print(ANSI_BLUE + "-5-" + ANSI_RESET + " Exit"); int input = 0; @@ -40,12 +51,18 @@ public class SpielCLI { switch (input) { case 1: - System.out.println("Noch nicht implementiert."); + spielStarten(); break; case 2: - System.out.println(spiel.toString()); + addSpieler(); break; case 3: + System.out.println(spiel.toString()); + break; + case 4: + spielerLöschen(); + break; + case 5: break mainloop; case 0: System.out.println("Diese eingabe ist nicht vergeben."); @@ -54,4 +71,96 @@ public class SpielCLI { System.out.println("auf wiedersehen!"); } + private void spielStarten() { + this.spiel.starteSpiel(); + System.out.println("Noch nicht implementiert."); + } + + private void addSpieler() { + int spieler_anzahl = this.spiel.getAlleSpieler().length; + if (spieler_anzahl <= 5) { + System.out.println("Gib den Namen des Spielers an"); + String name = sc.nextLine(); + System.out.println("Gib das Geschlecht an."); + System.out.println("Männlich (M), Weiblich (W), Divers (D), KI (K)"); + String geschlecht = sc.nextLine(); + switch (geschlecht) { + case "W": + spiel.addSpieler(name, Geschlecht.W); + break; + case "M": + spiel.addSpieler(name, Geschlecht.M); + break; + case "D": + spiel.addSpieler(name, Geschlecht.D); + break; + case "K": + spiel.addSpieler(name, Geschlecht.KI); + break; + default: + System.out.println("Diese eingabe ist nicht gültig"); + break; + + } + + } else { + System.out.println("Die Maximale Spieleranzahl ist erreicht."); + } + + } + + private void spielerLöschen() { + + if (this.spiel.getAlleSpieler().length >= 1) { + System.out.println("Welchen Spieler willst du löschen?"); + System.out.println("Gib die ID des Spielers an."); + + String[] spieler = spiel.getAlleSpieler(); + for (int i = 0; i < spieler.length; i++) { + System.out.println(spieler[i]); + } + + int _id = Integer.parseInt(sc.nextLine()); + // System.out.println(_id); + for (String s : spieler) { + if (s.contains("ID: " + _id)) { + System.out.println("Sicher das du " + s + " löschen willst?"); + } else { + System.out.println("Diese Spieler ist nicht vorhanden!"); + _id = 0; + } + } + boolean valid_choice = false; + while (!valid_choice) { + System.out.println("Ja [j] Nein [n]"); + String wahl = sc.nextLine(); + switch (wahl) { + case "j": + valid_choice = true; + try { + spiel.removeSpieler(_id); + System.out.println("Spieler löschen erfolgreich!"); + } catch (SpielerNotFoundException | EmptyListException | RuntimeException e) { + System.out.println(e.getMessage()); + } + + break; + case "n": + System.out.println("Spieler löschen abgebrochen!"); + valid_choice = true; + break; + default: + System.out.println("Diese Auswhal ist nicht gültig"); + } + } + } else { + System.out.println("Es existieren keine Spieler zum löschen."); + } + + } + + private void print(String message) { + System.out.println(message); + } + } \ No newline at end of file