Merge branch 'main' into iss#6

.gitignore

@@ -10,3 +10,5 @@
 # Jar dateien
 /lib
 .idea
+/Main.class
+/RendomTest.class

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+}

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();
+	}
+
 }

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);
+    }
+}

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)
+    /*------------------------------------------*/
+}

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);
+    }
+
+}

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)
 }

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() {
+	public Magierkarte(int id) {
-		super();
+		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
-	
+
 }

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() {
+	public Narrenkarte(int id) {
-		super();
+		super(id);
-	}
+		setName();
-	
+
-	public Narrenkarte(Kartenfarbe farbe, String bezeichnung) {
-		super();
-		setFarbe(farbe);
-		setBezeichnung(bezeichnung);
 	}
 	// Statische Methoden
-	
+
 	// Getter und Setter
+	
 	public int getId() {
-		return Karte.getId_card();
+		return super.getId();
 	}
-	
+
-	public void setFarbe(Kartenfarbe farbe) {
+	private void setName() {
-		this.farbe = farbe;
+		this.name = NAME;
 	}
-	public Kartenfarbe getFarbe() {
+
-		return this.farbe;
+	public String getName() {
+		return this.name;
 	}
-	
+
-	public void setBezeichnung(String bezeichnung) {
+	public void setNarrenkarteanzahl(int narrenkarteanzahl) {
-		this.bezeichnung = bezeichnung;
+		narrenkarteanzahl++;
-	}
-	public String getBezeichnung() {
-		return this.bezeichnung;
 	}
+
 	// @Overrides
-	
+	@Override
+	public String toString() {
+		return "ID " + this.getId() + ": " + this.getName();
+	}
 	// Public Methoden
-	
+
 	// Private Methoden
-	
+
 }

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);
+	}
 
-    /*------------------------------------------*/
+	public Zahlenkarte(int id, Kartenfarbe farbe, int kartenNummer) {
-    // statische Methoden
+		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;
+	}
 
-    /*------------------------------------------*/
+	public Kartenfarbe getFarbe() {
-    // öffentliche Methodes
+		return farbe;
-    /*------------------------------------------*/
+	}
 
-    /*------------------------------------------*/
+	public void setKartenNummer(int kartenNummer) {
-    // Hilfsmethoden (privat)
+		this.kartenNummer = kartenNummer;
-    /*------------------------------------------*/
+	}
 
-}
+	public int getKartenNummer() {
+		return kartenNummer;
+	}
+
+	/*------------------------------------------*/
+	// @Overrides
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
+	// öffentliche Methodes
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
+	// Hilfsmethoden (privat)
+	/*------------------------------------------*/
+
+}

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
-	// statische Attribute(zB. zähler)
+	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<Integer, Karte> kartensortiert = new HashMap<>();
 
-	/*------------------------------------------*/
+	private HashMap<Integer, Karte> kartengemischt = new HashMap<>();
-	// Attribute jedes Objektes
-	/*------------------------------------------*/
-
-	private Karte[] kartenStapel = new Karte[60];
-
-	/*------------------------------------------*/
-	// Konstruktoren (default und spezifische)
-	/*------------------------------------------*/
 
+	// 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() {
+	public Collection<Karte> getKartenstapelSortiert() {
-		return kartenStapel[0];
+		return kartensortiert.values();
+	}
+
+	public Collection<Karte> 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() {
+	public HashMap<Integer, String> getStatusGemischt() {
-		return kartenStapel.length;
+		HashMap<Integer, String> kg = new HashMap<>();
+		for (int i = 1; i <= 60; i++) {
+			kg.put(i, ((String) kartengemischt.get(i).toString()));
+		}
+		return kg;
 	}
 
-	/*------------------------------------------*/
+	/**
-	// @Overrides
+	 * 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
-	// öffentliche Methoden
+	 *       '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<Integer> 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
 
 }

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);
+		if (id < 6) {
-		setName(name);
+			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

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)
+    /*------------------------------------------*/
+
+}

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<Integer, Spieler> spieler = new HashMap<>();
+    private HashMap<Integer, Stich> 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: "
+        String text = "\n";
-                + (istSpielBeendet() ? "Ja" : "Nein") + ", Spieler am Zug: " + getSpielerAmZug()[0];
+        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) {
+    public void removeSpieler(int id_spieler) throws SpielerNotFoundException, EmptyListException, RuntimeException {
-        this.spieler.remove(id_spieler);
+        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++) {
+        int zähler = 0;
-            spieler_text[i] = this.spieler.get(i).toString();
+        for (Spieler s : this.spieler.values()) {
+            spieler_text[zähler] = s.toString();
+            zähler++;
         }
         return spieler_text;
     }
 
     public void starteSpiel() {
-        this.istGestartet = true;
+        // sing genügend Spieler angelegt?
-        // Gameloop?
+        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;
+        }
+    }
+
 }

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
+}

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());
+
+	}
+
 }

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());
+
+		
+	}
 }

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<Integer, Karte> 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());
+		
+		
+		
+	}	
+		
+
 }

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

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));
+    }
 }

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");
+            print("");
-            System.out.println("Was sillst du tun");
+            print("--------Hauptmenü--------");
-            System.out.println("--------Hauptmenü--------");
+            print(ANSI_BLUE + "-1-" + ANSI_RESET + " Spiel starten");
-            System.out.println("-1- Spiel starten");
+            print(ANSI_BLUE + "-2-" + ANSI_RESET + " Spieler hinzufügen");
-            System.out.println("-2- Spiel to String");
+            print(ANSI_BLUE + "-3-" + ANSI_RESET + " Spiel to String");
-            System.out.println("-3- Exit");
+            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);
+    }
+
 }