Merge pull request 'iss#6' (#43) from iss#6 into main

Reviewed-on: #43
Reviewed-by: Kai Sellmann <2210892@stud.hs-mannheim.de>

.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/Block/Block.java

@@ -6,13 +6,24 @@ written on: 05 / 10 / 2023 at: 23:43
 */
 package Domain.Block;
 
+import java.util.ArrayList;
+
 public class Block {
-    public void addZeile(){
+    private ArrayList<Blockzeile> zeilen;
 
+    public Block(){
+        this.zeilen = new ArrayList<>();
     }
 
-    public Blockzeile[] getDaten() {
-        return null;
+    public void addZeile(Blockzeile blockzeile) {
+        zeilen.add(blockzeile);
+    }
+
+    public Blockzeile[] getDaten(){
+        if(zeilen.isEmpty()){
+            System.out.println("Die Liste der Blockzeilen ist Leer. ");
+            return zeilen.toArray(new Blockzeile[0]);
+        }
+        return zeilen.toArray(new Blockzeile[0]);
     }
-    //neues Kommentar
 }

Domain/Block/Blockeintrag.java

@@ -6,17 +6,25 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
-public class Blockeintrag {
-    public int punkte;
-    public int stiche;
+import Domain.Spieler;
 
+import java.util.Objects;
+
+public class Blockeintrag {
+    private int punkte;
+    private int stiche;
+    private Spieler id;
     public Blockeintrag() {
 
     }
 
-    public Blockeintrag(int punkte, int stiche) {
-        this.punkte = punkte;
+    public Blockeintrag(int punkte, int stiche, Spieler id) {
+        if(stiche < 0){
+            throw new IllegalArgumentException("Ihre Stiche dürfen nicht im Negativen bereich sein");
+        }
         this.stiche = stiche;
+        this.punkte = punkte;
+        this.id = id;
     }
 
     public int getPunkte() {
@@ -28,6 +36,9 @@ public class Blockeintrag {
     }
 
     public void setStiche(int stiche) {
+        if (stiche < 0){
+            throw new IllegalArgumentException("Ihre Stich dürfen nicht im Negative bereich sein");
+        }
         this.stiche = stiche;
     }
 
@@ -35,4 +46,31 @@ public class Blockeintrag {
         this.punkte = punkte;
     }
 
+    public Spieler getId() {
+        return id;
+    }
+
+    @Override
+    public boolean equals(Object ob){
+        if (this == ob) {
+            return true;
+        }
+        if (ob == null || getClass() != ob.getClass()) {
+            return false;
+        }
+
+        Blockeintrag andererEintrag = (Blockeintrag) ob;
+        return this.punkte == andererEintrag.punkte && this.stiche == andererEintrag.stiche
+                && Objects.equals(this.id, andererEintrag.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(punkte, stiche, id);
+    }
+
+    @Override
+    public String toString() {
+        return getPunkte() + ", S: " + getStiche() + " | ";
+    }
 }

Domain/Block/Blockzeile.java

@@ -6,6 +6,8 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
+import java.util.ArrayList;
+
 public class Blockzeile {
 
     /*------------------------------------------*/
@@ -21,17 +23,21 @@ public class Blockzeile {
     /*------------------------------------------*/
 
     private int rundenNummer;
-    private Blockeintrag[] eintraege;
+    private ArrayList<Blockeintrag> eintraege;
 
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
 
-    public Blockzeile(int rundenNummer, int spielerAnzahl) {
-        this.rundenNummer = rundenNummer;
-        this.eintraege = new Blockeintrag[spielerAnzahl];
+    public Blockzeile(){
+
     }
 
+    public Blockzeile(int rundenNummer, Blockeintrag eintrag) {
+        this.rundenNummer = rundenNummer;
+        this.eintraege = new ArrayList<>();
+        addEintrag(eintrag);
+    }
     /*------------------------------------------*/
     // statische Methoden
     /*------------------------------------------*/
@@ -39,7 +45,13 @@ public class Blockzeile {
     /*------------------------------------------*/
     // Getter und Setter
     /*------------------------------------------*/
+    public int getRundenNummer() {
+        return rundenNummer;
+    }
 
+    public void setRundenNummer(int rundenNummer) {
+        this.rundenNummer = rundenNummer;
+    }
     /*------------------------------------------*/
     // @Overrides
     /*------------------------------------------*/
@@ -48,21 +60,27 @@ public class Blockzeile {
     // öffentliche Methodes
     /*------------------------------------------*/
 
-    public void addEintrag(Blockeintrag be) {
-
-        for (int i = 0; i < eintraege.length; i++) {
-            if (eintraege[i] == null) {
-                eintraege[i] = be;
-            }
+    public void addEintrag(Blockeintrag eintrag) {
+        if(eintraege != null){
+            eintraege.add(eintrag);
         }
     }
 
     public Blockeintrag[] getDaten() {
-        return eintraege;
+        return eintraege.toArray(new Blockeintrag[0]);
     }
-
     /*------------------------------------------*/
     // Hilfsmethoden (privat)
     /*------------------------------------------*/
 
+    public Blockeintrag[] getValidDaten() {
+        Blockeintrag[] dataArray = getDaten();
+
+        for (Blockeintrag eintrag : dataArray) {
+            if (eintrag == null) {
+                throw new IllegalStateException("Das Array ist leer");
+            }
+        }
+        return dataArray;
+    }
 }

Domain/Enums/Kartenfarbe.java

@@ -12,7 +12,7 @@ public enum Kartenfarbe {
 
 	private String farbe;
 
-	private Kartenfarbe (String farbe) {
+	private Kartenfarbe(String farbe) {
 		this.farbe = farbe;
 	}
 

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,37 +6,47 @@ 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";
+	private final static String NAME = "Zauberer";
 	// Statische Attribute
 
 	// Attribute des Objekts
-	private String bezeichnung;
+	
+	private String name;
+	
 	// Konstruktoren
 
-	public Magierkarte() {
-		super();
-		setBezeichnung(TRUMPF_NAME);
+	public Magierkarte(int id) {
+		super(id);
+		setName();
+
 	}
 
 	// Statische Methoden
 
 	// Getter und Setter
 
-	public void setBezeichnung(String bezeichnung) {
-		this.bezeichnung = bezeichnung;
+	public int getId() {
+		return super.getId();
 	}
 
-	public String getBezeichnung() {
-		return this.bezeichnung;
+	private void setName() {
+		this.name = NAME;
 	}
 
+	public String getName() {
+		return this.name;
+	}
+
+
 	// @Overrides
 	@Override
 	public String toString() {
-		return this.getBezeichnung();
+		return "ID " + this.getId() +  ": " + this.getName();
 	}
 	// Public Methoden
 

Domain/Karten/Narrenkarte.java

@@ -6,37 +6,48 @@ 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";
+	private final static String NAME = "Narr";
 	// Statische Attribute
 
 	// Attribute des Objekts
-	private String bezeichnung;
+	
+	private String name;
 	// Konstruktoren
 
-	public Narrenkarte() {
-		super();
-		setBezeichnung(TRUMPF_NAME);
-	}
+	public Narrenkarte(int id) {
+		super(id);
+		setName();
 
+	}
 	// Statische Methoden
 
 	// Getter und Setter
 	
-	public void setBezeichnung(String bezeichnung) {
-		this.bezeichnung = bezeichnung;
+	public int getId() {
+		return super.getId();
 	}
 
-	public String getBezeichnung() {
-		return this.bezeichnung;
+	private void setName() {
+		this.name = NAME;
+	}
+
+	public String getName() {
+		return this.name;
+	}
+
+	public void setNarrenkarteanzahl(int narrenkarteanzahl) {
+		narrenkarteanzahl++;
 	}
 
 	// @Overrides
 	@Override
 	public String toString() {
-		return this.getBezeichnung();
+		return "ID " + this.getId() + ": " + this.getName();
 	}
 	// Public Methoden
 

Domain/Karten/Zahlenkarte.java

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

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
 	
-	/*------------------------------------------*/
-	// Attribute jedes Objektes
-	/*------------------------------------------*/
+	/**
+	 * 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 Karte[] kartenStapel = new Karte[60];
-
-	/*------------------------------------------*/
-	// Konstruktoren (default und spezifische)
-	/*------------------------------------------*/
+	private HashMap<Integer, Karte> 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<Karte> getKartenstapelSortiert() {
+		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() {
-		return kartenStapel.length;
+	public HashMap<Integer, String> getStatusGemischt() {
+		HashMap<Integer, String> 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<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);
 		}
 		
-	/*------------------------------------------*/
-	// Hilfsmethoden (privat)
-	/*------------------------------------------*/
+		for(Karte k : kartengemischt.values()) {
+			System.out.println(k.toString());
+		}
+	}
 
-	//
+	/**
+	 * 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
@@ -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: "
-                + (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) {
+    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() {
+        // 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/Block/BlockTest.java

@@ -6,6 +6,96 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockTest {
+import Domain.Block.Block;
+import Domain.Block.Blockeintrag;
+import Domain.Block.Blockzeile;
+import Domain.Enums.Geschlecht;
+import Facade.Spiel;
+import org.junit.Test;
 
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+
+public class BlockTest {
+    Block block = new Block();
+    Blockeintrag b1 = new Blockeintrag(20,0,null);
+    Blockeintrag b2 = new Blockeintrag(30,1,null);
+    Blockeintrag b3 = new Blockeintrag(40,2,null);
+    Blockeintrag b4 = new Blockeintrag(20,0,null);
+    Blockeintrag b5 = new Blockeintrag(30,1,null);
+    Blockeintrag b6 = new Blockeintrag(40,2,null);
+
+    Blockzeile z1 = new Blockzeile(1,b1);
+    Blockzeile z2 = new Blockzeile(2,b2);
+    Blockzeile z3 = new Blockzeile(3, b3);
+    Blockzeile z4 = new Blockzeile(1,b1);
+    Blockzeile z5 = new Blockzeile(2,b2);
+    Blockzeile z6 = new Blockzeile(3, b3);
+
+    /**
+     * Testet die Methode addZeile in der Block-Klasse.
+     * Überprüft, ob die Anzahl der Zeilen im Block nach dem Hinzufügen korrekt ist
+     * und ob die hinzugefügte Zeile an der richtigen Position im Datenarray steht.
+     */
+    @Test
+    public void addZeileTest() {
+        block.addZeile(z1);
+        block.addZeile(z2);
+        block.addZeile(z3);
+
+        z1.addEintrag(b1);
+        z1.addEintrag(b2);
+        z1.addEintrag(b3);
+        z2.addEintrag(b1);
+        z2.addEintrag(b2);
+        z2.addEintrag(b3);
+        z3.addEintrag(b1);
+        z3.addEintrag(b2);
+        z3.addEintrag(b3);
+
+        assertEquals(3,block.getDaten().length);
+        assertTrue((z1 == block.getDaten()[0]) &&
+                (z2 == block.getDaten()[1]) && (z3 == block.getDaten()[2]));
+
+    }
+
+    /**
+     * Testet die Methode getDaten der Klasse Block. Überprüft, ob die Daten im
+     * Block korrekt abgerufen werden können.
+     */
+    @Test
+    public void getDatenTest() {
+        block.addZeile(z4);
+        block.addZeile(z5);
+        block.addZeile(z6);
+
+        z1.addEintrag(b4);
+        z1.addEintrag(b5);
+        z1.addEintrag(b6);
+        z2.addEintrag(b4);
+        z2.addEintrag(b5);
+        z2.addEintrag(b6);
+        z3.addEintrag(b4);
+        z3.addEintrag(b5);
+        z3.addEintrag(b6);
+
+        assertTrue((block.getDaten()[0].getDaten()[0].getPunkte() ==20)
+        && (block.getDaten()[0].getDaten()[0].getStiche() == 0)
+        && (block.getDaten()[1].getDaten()[0].getPunkte() == 30)
+        && (block.getDaten()[1].getDaten()[0].getStiche() == 1)
+        && (block.getDaten()[2].getDaten()[0].getPunkte() == 40)
+        && (block.getDaten()[2].getDaten()[0].getStiche() == 2));
+
+    }
+
+    /**
+     * Testet die Methode getDaten der Klasse Block für einen leeren Block.
+     * Überprüft, ob für einen leeren Block ein leeres Datenarray zurückgegeben
+     * wird.
+     */
+    @Test
+    public void getDatenTestLeererBlock(){
+        Block block2 = new Block();
+        assertEquals(0, block2.getDaten().length);
+    }
 }

Test/Domain/Block/BlockeintragTest.java

@@ -6,6 +6,39 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockeintragTest {
+import Domain.Block.Blockeintrag;
+import org.junit.Test;
 
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+public class BlockeintragTest {
+    @Test
+    public void getPunkteTest(){
+        Blockeintrag eintrag = new Blockeintrag(20,0,null);
+        assertTrue((eintrag.getPunkte() == 20));
+        eintrag.setPunkte(30);
+        assertTrue((eintrag.getPunkte() == 30));
+        eintrag.setPunkte(40);
+        assertTrue((eintrag.getPunkte()== 40));
+    }
+
+    @Test
+    public void getStiche() {
+        Blockeintrag eintrag = new Blockeintrag(30,1,null);
+        assertEquals(1, eintrag.getStiche());
+        eintrag.setStiche(2);
+        assertEquals(2, eintrag.getStiche());
+        eintrag.setStiche(3);
+        assertEquals(3, eintrag.getStiche());
+    }
+
+    //Exception Test hier schreiben
+    @Test
+    public void testNegativeStiche() throws Exception {
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3, null));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1, null));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4, null));
+    }
 }

Test/Domain/Block/BlockzeileTest.java

@@ -6,6 +6,102 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockzeileTest {
+import Domain.Block.Block;
+import Domain.Block.Blockeintrag;
+import Domain.Block.Blockzeile;
+import org.junit.Test;
 
+import static org.junit.Assert.assertEquals;
+
+public class BlockzeileTest {
+    Block b = new Block();
+    Blockeintrag e1 = new Blockeintrag(20,0,null);
+    Blockeintrag e2 = new Blockeintrag(30,1,null);
+    Blockeintrag e3 = new Blockeintrag(40,2,null);
+    Blockeintrag e4 = new Blockeintrag(50,2, null);
+    Blockeintrag e5 = new Blockeintrag(50, 2, null);
+    Blockeintrag e6 = new Blockeintrag(40, 1, null);
+    Blockzeile z1 = new Blockzeile(1, e1);
+    Blockzeile z2 = new Blockzeile(2, e2);
+    Blockzeile z3 = new Blockzeile(3, e3);
+
+    /**
+     * testet addEintrag
+     * Anmerkung assertEquals überprüft nicht ob der Eintrag richtig ist sondern ob das
+     * Objekt eintrag1 im array liegt Eintrag wird in Blockeintrag auf Richtigkeit
+     * getestet
+     */
+    @Test
+    public void addEintragTest() {
+        Blockeintrag[] daten;
+
+        //1 Eintrag
+        z1.addEintrag(e1);
+        z1.addEintrag(e2);
+        daten = z1.getDaten();
+        assertEquals("addEintrag: 1 Eintrag", 3, daten.length);
+        assertEquals("addEintrag: 1 Eintrag", e1, daten[1]);
+        assertEquals("addEintrag: 1 Eintrag", e2, daten[2]);
+
+        //2 Eintrag
+        z1.addEintrag(e3);
+        z1.addEintrag(e4);
+        daten = z1.getDaten();
+        assertEquals("addEintrag: 2 Eintrag", 5, daten.length);
+        assertEquals("addEintrag: 2 Eintrag", e3, daten[3]);
+        assertEquals("addEintrag: 2 Eintrag", e4, daten[4]);
+
+        //3 Eintrag
+        z1.addEintrag(e5);
+        z1.addEintrag(e6);
+        daten = z1.getDaten();
+        assertEquals("addEintrag: 3 Eintrag", 7, daten.length);
+        assertEquals("addEintrag: 3 Eintrag", e5, daten[5]);
+        assertEquals("addEintrag: 3 Eintrag", e6, daten[6]);
+    }
+
+    //Überprüfung ob Daten korrekt zurückgegeben werden
+    @Test
+    public void getDatenTest() {
+
+        z1.addEintrag(e1);
+        z1.addEintrag(e2);
+
+        Blockeintrag[] daten = z1.getDaten();
+
+        assertEquals(3, daten.length);
+        assertEquals(e1, daten[1]);
+        assertEquals(e2, daten[2]);
+
+        z1.addEintrag(null);
+        Blockeintrag[] daten1 = z1.getDaten();
+    }
+
+    @Test
+    public void duplikateRunde() throws Exception{
+        Blockeintrag e1 = new Blockeintrag(30,1,null);
+        Blockeintrag e2 = new Blockeintrag(20,0,null);
+
+        Blockzeile z1 = new Blockzeile(4, e1);
+        Blockzeile z2 = new Blockzeile(4, e2);
+    }
+
+    @Test
+    public void invalidRunde() throws Exception{
+        Blockzeile z4 = new Blockzeile(-1, e1);
+    }
+
+    @Test
+    public void invalidRunde2() throws Exception{
+        Blockzeile z5 = new Blockzeile(-3, e2);
+    }
+
+    @Test
+    public void getRundenNummer(){
+        assertEquals(3, z3.getRundenNummer());
+        z3.setRundenNummer(4);
+        assertEquals(4, z3.getRundenNummer());
+        z3.setRundenNummer(5);
+        assertEquals(5, z3.getRundenNummer());
+    }
 }

Test/Domain/Karten/MagierkarteTest.java

@@ -7,39 +7,33 @@ 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.Enums.Kartenfarbe;
 import Domain.Karten.Magierkarte;
 
-/**
- * 
- * @author sellm
- * @version
- * 
- *
- */
 
 public class MagierkarteTest {
 
+	
 	@Test
 	public void vierMagier() {
-		Magierkarte m1 = new Magierkarte();
-		Magierkarte m2 = new Magierkarte();
-		Magierkarte m3 = new Magierkarte();
-		Magierkarte m4 = new Magierkarte();
+		Magierkarte m1 = new Magierkarte(1);
+		Magierkarte m2 = new Magierkarte(2);
+		Magierkarte m3 = new Magierkarte(3);
+		Magierkarte m4 = new Magierkarte(4);
 
 		
-		assertEquals("Zauberer", m1.getBezeichnung());
+		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("Zauberer", m2.getBezeichnung());
-		
-		assertEquals("Zauberer", m3.getBezeichnung());
-		
-		assertEquals("Zauberer", m4.getBezeichnung());
-		
-		
-		assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());
+		assertEquals("ID 1: Zauberer", m1.toString());
 
 	}
 

Test/Domain/Karten/NarrenkarteTest.java

@@ -7,23 +7,33 @@ 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();
-		Narrenkarte n2 = new Narrenkarte();
-		Narrenkarte n3 = new Narrenkarte();
-		Narrenkarte n4 = new Narrenkarte();
+		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());
 
-		assertEquals(n1.getBezeichnung(), "Narr");
-		assertEquals(n2.getBezeichnung(), "Narr");
-		assertEquals(n3.getBezeichnung(), "Narr");
-		assertEquals(n4.getBezeichnung(), "Narr");
 		
 	}
 }

Test/Domain/Karten/ZahlenkarteTest.java

@@ -7,89 +7,81 @@ 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 {
 
-	/**
-	 * Die Objekterzeugung der HashMap und der Zahlenkarten
-	 * kann auch in ein @BeforeAll eingetragen werden.
-	 */
-
-	/**
-	 * Der @Test erzeugt Zahlenkarten von 1 bis 13. prüft aber
-	 * nur zwei Positionen in der HashMap, um die
-	 * Objektdaten zu validieren.
-	 */
-	@Test
-	public void dreizehnZahlenkartenMENSCH() {
-
-		HashMap<Integer, Zahlenkarte> zm = new HashMap<Integer, Zahlenkarte>();
-		Zahlenkarte zahlenkarte = null;
-		for (int i = 1; i <= 13; i++) {
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.MENSCH, i);
-			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);
-	}
 	
 	@Test
-	public void dreizehnZahlenkartenElf() {
-		HashMap<Integer, Zahlenkarte> ze = new HashMap<Integer, Zahlenkarte>();
-		Zahlenkarte zahlenkarte = null;
-		for (int i = 1; i <= 13; i++) {
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.ELF, i);
-			ze.put(i, zahlenkarte);
+	public void zahlenkartentesten() {
+		
+		HashMap<Integer, Karte> zk = new HashMap<>();
+		
+		for (int i = 1; i <= 8; i++) {
+			zk.put(i, null);
 		}
 		
-		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);
+		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));
 		}
 		
-	@Test
-	public void dreizehnZahlenkartenZWERG() {
-		HashMap<Integer, Zahlenkarte> zz = new HashMap<Integer, Zahlenkarte>();
-		Zahlenkarte zahlenkarte = null;
-		for (int i = 1; i <= 13; i++) {
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.ZWERG, i);
-			zz.put(i, zahlenkarte);
-		}
+		// 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());
 		
-		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);
 		
 	}	
 		
-	@Test
-	public void dreizehnZahlenkartenRIESE() {
-		HashMap<Integer, Zahlenkarte> zr = new HashMap<Integer, Zahlenkarte>();
-		Zahlenkarte zahlenkarte = null;
-		for (int i = 1; i <= 13; i++) {
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.RIESE, i);
-			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");
-            System.out.println("--------Hauptmenü--------");
-            System.out.println("-1- Spiel starten");
-            System.out.println("-2- Spiel to String");
-            System.out.println("-3- Exit");
+        mainloop: while (true) {
+            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);
+    }
+
 }