.vscode/settings.json

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

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

@@ -11,22 +11,25 @@ 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
 

Domain/Karten/Magierkarte.java

@@ -6,25 +6,48 @@ written on: 05 / 10 / 2023 at: 23:41
 */
 package Domain.Karten;
 
+import Domain.Enums.Kartenfarbe;
+
 public class Magierkarte extends Karte {
 
 	// Statische Konstanten
-	private static String TRUMPF_NAME = "Zauberer";
+
 	// Statische Attribute
 
 	// Attribute des Objekts
+	private Kartenfarbe kartenfarbe;
 	private String bezeichnung;
+	private static int magierkartenanzahl = 0;
 	// Konstruktoren
 
-	public Magierkarte() {
+	public Magierkarte(int id) {
+		super(id);
+
+	}
+
+	public Magierkarte(Kartenfarbe kartenfarbe, String bezeichnung) {
 		super();
-		setBezeichnung(TRUMPF_NAME);
+		setKartenfarbe(kartenfarbe);
+		setBezeichnung(bezeichnung);
+
 	}
 
 	// Statische Methoden
 
 	// Getter und Setter
 
+	public void setKartenfarbe(Kartenfarbe kartenfarbe) {
+		this.kartenfarbe = kartenfarbe;
+	}
+
+	public Kartenfarbe getKartenfarbe() {
+		return this.kartenfarbe;
+	}
+
+	public int getId() {
+		return this.getId();
+	}
+
 	public void setBezeichnung(String bezeichnung) {
 		this.bezeichnung = bezeichnung;
 	}
@@ -33,10 +56,19 @@ public class Magierkarte extends Karte {
 		return this.bezeichnung;
 	}
 
+	public void setMagierkartenanzahl(int magierkartenanzahl) {
+		magierkartenanzahl++;
+	}
+
+	public int getMagierkartenanzahl() {
+		return magierkartenanzahl;
+	}
+
 	// @Overrides
 	@Override
 	public String toString() {
-		return this.getBezeichnung();
+		return this.getBezeichnung() + ": " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe().toString()
+				+ ").";
 	}
 	// Public Methoden
 

Domain/Karten/Narrenkarte.java

@@ -6,24 +6,43 @@ written on: 05 / 10 / 2023 at: 23:41
 */
 package Domain.Karten;
 
+import Domain.Enums.Kartenfarbe;
+
 public class Narrenkarte extends Karte {
 
 	// Statische Konstanten
-	private static String TRUMPF_NAME = "Narr";
+
 	// Statische Attribute
 
 	// Attribute des Objekts
+	private Kartenfarbe kartenfarbe;
 	private String bezeichnung;
 	// Konstruktoren
 
-	public Narrenkarte() {
+	public Narrenkarte(int id) {
-		super();
+		super(id);
-		setBezeichnung(TRUMPF_NAME);
 	}
 
+	public Narrenkarte(Kartenfarbe farbe, String bezeichnung) {
+		super();
+		setKartenfarbe(farbe);
+		setBezeichnung(bezeichnung);
+
+	}
 	// Statische Methoden
 
 	// Getter und Setter
+	public int getId() {
+		return this.getId();
+	}
+
+	public void setKartenfarbe(Kartenfarbe farbe) {
+		this.kartenfarbe = farbe;
+	}
+
+	public Kartenfarbe getKartenfarbe() {
+		return this.kartenfarbe;
+	}
 
 	public void setBezeichnung(String bezeichnung) {
 		this.bezeichnung = bezeichnung;
@@ -33,10 +52,15 @@ public class Narrenkarte extends Karte {
 		return this.bezeichnung;
 	}
 
+	public void setNarrenkarteanzahl(int narrenkarteanzahl) {
+		narrenkarteanzahl++;
+	}
+
 	// @Overrides
 	@Override
 	public String toString() {
-		return this.getBezeichnung();
+		return this.getBezeichnung() + ": " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe().toString()
+				+ ").";
 	}
 	// Public Methoden
 

Domain/Karten/Zahlenkarte.java

@@ -21,7 +21,7 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// Attribute jedes Objektes
 	/*------------------------------------------*/
-	private Kartenfarbe kartenfarbe;
+	private Kartenfarbe farbe;
 	private int kartenNummer;
 
 	/*------------------------------------------*/
@@ -31,9 +31,9 @@ public class Zahlenkarte extends Karte {
 		super();
 	}
 
-	public Zahlenkarte(Kartenfarbe kartenfarbe, int kartenNummer) {
+	public Zahlenkarte(Kartenfarbe farbe, int kartenNummer) {
 		super();
-		setKartenfarbe(kartenfarbe);
+		setFarbe(farbe);
 		setKartenNummer(kartenNummer);
 
 	}
@@ -44,12 +44,12 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// Getter und Setter
 	/*------------------------------------------*/
-	public void setKartenfarbe(Kartenfarbe kartenfarbe) {
+	public void setFarbe(Kartenfarbe farbe) {
-		this.kartenfarbe = kartenfarbe;
+		this.farbe = farbe;
 	}
 
-	public Kartenfarbe getKartenfarbe() {
+	public Kartenfarbe getFarbe() {
-		return kartenfarbe;
+		return farbe;
 	}
 
 	public void setKartenNummer(int kartenNummer) {
@@ -63,10 +63,7 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// @Overrides
 	/*------------------------------------------*/
-	@Override
+
-	public String toString() {
-		return "Charakterkarte: " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe() + ").";
-	}
 	/*------------------------------------------*/
 	// öffentliche Methodes
 	/*------------------------------------------*/

Domain/Kartenstapel.java

@@ -6,6 +6,11 @@ written on: 05 / 10 / 2023 at: 23:42
 */
 package Domain;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import Domain.Enums.Kartenfarbe;
 import Domain.Karten.*;
 
 public class Kartenstapel {
@@ -21,6 +26,12 @@ public class Kartenstapel {
 	/*------------------------------------------*/
 	// Attribute jedes Objektes
 	/*------------------------------------------*/
+	private boolean[][] belegung = {
+			{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false },
+			{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false },
+			{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false },
+			{ false, false, false, false, false, false, false, false, false, false, false, false, false, false, false }
+	};
 
 	private Karte[] kartenStapel = new Karte[60];
 
@@ -29,6 +40,7 @@ public class Kartenstapel {
 	/*------------------------------------------*/
 
 	public Kartenstapel() {
+		mischen();
 
 	}
 
@@ -74,6 +86,37 @@ public class Kartenstapel {
 	// Hilfsmethoden (privat)
 	/*------------------------------------------*/
 
+	private void Kartenverteilung() {
+
+		Random r = new Random();
+		List<Karte> karten = new ArrayList<>();
+		while (karten.size() < 60) {
+			int high = 4;
+			int low = 1;
+			int ultra_high = 15;
+			int x = r.nextInt(high - low) + low;
+			int y = r.nextInt(ultra_high - low) + low;
+			if (!belegung[x - 1][y - 1]) {
+				if (y == 1) {
+					karten.add(new Narrenkarte(x * y));
+				} else if (y == 15) {
+					karten.add(new Magierkarte(x * y));
+				} else {
+					if (x == 1) {
+						karten.add(new Zahlenkarte(Kartenfarbe.ZWERG, y));
+					} else if (x == 2) {
+
+					} else if (x == 3) {
+
+					} else if (x == 4) {
+
+					}
+				}
+			}
+		}
+
+	}
+
 	//
 
 }

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
@@ -27,6 +27,7 @@ public class Spieler implements Serializable {
 	private String name;
 	private int vorhersage;
 	private Geschlecht geschlecht;
+	//
 
 	/*------------------------------------------*/
 	// Konstruktoren (default und spezifische)
@@ -50,17 +51,14 @@ public class Spieler implements Serializable {
 		this();
 		if (id < 6) {
 			setId(id);
-		}
+		} else {
-		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) {
-		else if (name.length() > 2) {
 			setName(name); // Es wird geprüft, ob Name größer 2 Zeichen
-		}
+		} else {
-		else {
 			throw new RuntimeException("Der Name muss länger als 2 Buchstaben sein.");
 		}
 		setGeschlecht(geschlecht);
@@ -122,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 {
+        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() {
+        // sing genügend Spieler angelegt?
+        if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
             this.istGestartet = true;
-        // Gameloop?
+            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

@@ -23,21 +23,23 @@ public class MagierkarteTest {
 
 	@Test
 	public void vierMagier() {
-		Magierkarte m1 = new Magierkarte();
+		Magierkarte m1 = new Magierkarte(Kartenfarbe.MENSCH, "Zauberer");
-		Magierkarte m2 = new Magierkarte();
+		Magierkarte m2 = new Magierkarte(Kartenfarbe.ELF, "Zauberer");
-		Magierkarte m3 = new Magierkarte();
+		Magierkarte m3 = new Magierkarte(Kartenfarbe.RIESE, "Zauberer");
-		Magierkarte m4 = new Magierkarte();
+		Magierkarte m4 = new Magierkarte(Kartenfarbe.ZWERG, "Zauberer");
-		
 
+		assertEquals(Kartenfarbe.MENSCH, m1.getKartenfarbe());
 		assertEquals("Zauberer", m1.getBezeichnung());
-		
+		assertEquals("BLAU", Kartenfarbe.MENSCH.getFarbe());
-		
+		assertEquals(Kartenfarbe.ELF, m2.getKartenfarbe());
 		assertEquals("Zauberer", m2.getBezeichnung());
-		
+		assertEquals("GRÜN", Kartenfarbe.ELF.getFarbe());
+		assertEquals(Kartenfarbe.RIESE, m3.getKartenfarbe());
 		assertEquals("Zauberer", m3.getBezeichnung());
-		
+		assertEquals("GELB", Kartenfarbe.RIESE.getFarbe());
+		assertEquals(Kartenfarbe.ZWERG, m4.getKartenfarbe());
 		assertEquals("Zauberer", m4.getBezeichnung());
-		
+		assertEquals("ROT", Kartenfarbe.ZWERG.getFarbe());
 
 		assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());
 

Test/Domain/Karten/NarrenkarteTest.java

@@ -7,23 +7,34 @@ written on: 10 / 10 / 2023 at: 21:18
 package Test.Domain.Karten;
 
 import static org.junit.Assert.assertEquals;
+
 import org.junit.Test;
 
+import Domain.Enums.Kartenfarbe;
 import Domain.Karten.Narrenkarte;
 
 public class NarrenkarteTest {
 
 	@Test
 	public void vierNarren() {
-		Narrenkarte n1 = new Narrenkarte();
+		Narrenkarte n1 = new Narrenkarte(Kartenfarbe.MENSCH, "Narr");
-		Narrenkarte n2 = new Narrenkarte();
+		Narrenkarte n2 = new Narrenkarte(Kartenfarbe.ELF, "Narr");
-		Narrenkarte n3 = new Narrenkarte();
+		Narrenkarte n3 = new Narrenkarte(Kartenfarbe.RIESE, "Narr");
-		Narrenkarte n4 = new Narrenkarte();
+		Narrenkarte n4 = new Narrenkarte(Kartenfarbe.ZWERG, "Narr");
+
+		assertEquals(n1.getKartenfarbe(), Kartenfarbe.MENSCH);
+		assertEquals(n2.getKartenfarbe(), Kartenfarbe.ELF);
+		assertEquals(n3.getKartenfarbe(), Kartenfarbe.RIESE);
+		assertEquals(n4.getKartenfarbe(), Kartenfarbe.ZWERG);
 
 		assertEquals(n1.getBezeichnung(), "Narr");
 		assertEquals(n2.getBezeichnung(), "Narr");
 		assertEquals(n3.getBezeichnung(), "Narr");
 		assertEquals(n4.getBezeichnung(), "Narr");
 
+		assertEquals(Kartenfarbe.MENSCH.getFarbe(), "BLAU");
+		assertEquals(Kartenfarbe.ELF.getFarbe(), "GRÜN");
+		assertEquals(Kartenfarbe.RIESE.getFarbe(), "GELB");
+		assertEquals(Kartenfarbe.ZWERG.getFarbe(), "ROT");
 	}
 }

Test/Domain/Karten/ZahlenkarteTest.java

@@ -37,10 +37,8 @@ public class ZahlenkarteTest {
 			zm.put(i, zahlenkarte);
 		}
 
-		assertEquals(zm.get(7).getKartenfarbe(), Kartenfarbe.MENSCH);
 		assertEquals(zm.get(7).getKartenNummer(), 7);
 
-		assertEquals(zm.get(4).getKartenfarbe(), Kartenfarbe.MENSCH);
 		assertEquals(zm.get(4).getKartenNummer(), 4);
 	}
 
@@ -53,10 +51,8 @@ public class ZahlenkarteTest {
 			ze.put(i, zahlenkarte);
 		}
 
-		assertEquals(ze.get(7).getKartenfarbe(), Kartenfarbe.ELF);
 		assertEquals(ze.get(7).getKartenNummer(), 7);
 
-		assertEquals(ze.get(4).getKartenfarbe(), Kartenfarbe.ELF);
 		assertEquals(ze.get(4).getKartenNummer(), 4);
 	}
 
@@ -69,10 +65,8 @@ public class ZahlenkarteTest {
 			zz.put(i, zahlenkarte);
 		}
 
-		assertEquals(zz.get(7).getKartenfarbe(), Kartenfarbe.ZWERG);
 		assertEquals(zz.get(7).getKartenNummer(), 7);
 
-		assertEquals(zz.get(4).getKartenfarbe(), Kartenfarbe.ZWERG);
 		assertEquals(zz.get(4).getKartenNummer(), 4);
 
 	}
@@ -86,10 +80,8 @@ public class ZahlenkarteTest {
 			zr.put(i, zahlenkarte);
 		}
 
-		assertEquals(zr.get(9).getKartenfarbe(), Kartenfarbe.RIESE);
 		assertEquals(zr.get(9).getKartenNummer(), 9);
 
-		assertEquals(zr.get(2).getKartenfarbe(), Kartenfarbe.RIESE);
 		assertEquals(zr.get(2).getKartenNummer(), 2);
 	}
 }

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

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() {
-        mainloop: while (true) {
         System.out.println("Hallo Wanderer");
-            System.out.println("Was sillst du tun");
+        mainloop: while (true) {
-            System.out.println("--------Hauptmenü--------");
+            print("");
-            System.out.println("-1- Spiel starten");
+            print("--------Hauptmenü--------");
-            System.out.println("-2- Spiel to String");
+            print(ANSI_BLUE + "-1-" + ANSI_RESET + " Spiel starten");
-            System.out.println("-3- Exit");
+            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);
+    }
+
 }