update spieler package-sichtbarkeit

.gitignore

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

.vscode/settings.json

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

Domain/Block/Block.java

@@ -6,24 +6,13 @@ written on: 05 / 10 / 2023 at: 23:43
 */
 package Domain.Block;
 
-import java.util.ArrayList;
-
 public class Block {
-    private ArrayList<Blockzeile> zeilen;
+    public void addZeile(){
 
-    public Block(){
-        this.zeilen = new ArrayList<>();
     }
 
-    public void addZeile(Blockzeile blockzeile) {
+    public Blockzeile[] getDaten() {
-        zeilen.add(blockzeile);
+        return null;
     }
-
+    //neues Kommentar
-    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]);
-    }
-}

Domain/Block/Blockeintrag.java

@@ -6,25 +6,17 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
-import Domain.Spieler;
-
-import java.util.Objects;
-
 public class Blockeintrag {
-    private int punkte;
+    public int punkte;
-    private int stiche;
+    public int stiche;
-    private Spieler id;
+
     public Blockeintrag() {
 
     }
 
-    public Blockeintrag(int punkte, int stiche, Spieler id) {
+    public Blockeintrag(int punkte, int stiche) {
-        if(stiche < 0){
-            throw new IllegalArgumentException("Ihre Stiche dürfen nicht im Negativen bereich sein");
-        }
-        this.stiche = stiche;
         this.punkte = punkte;
-        this.id = id;
+        this.stiche = stiche;
     }
 
     public int getPunkte() {
@@ -36,9 +28,6 @@ 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;
     }
 
@@ -46,31 +35,4 @@ 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,8 +6,6 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
-import java.util.ArrayList;
-
 public class Blockzeile {
 
     /*------------------------------------------*/
@@ -23,21 +21,17 @@ public class Blockzeile {
     /*------------------------------------------*/
 
     private int rundenNummer;
-    private ArrayList<Blockeintrag> eintraege;
+    private Blockeintrag[] eintraege;
 
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
 
-    public Blockzeile(){
+    public Blockzeile(int rundenNummer, int spielerAnzahl) {
-
-    }
-
-    public Blockzeile(int rundenNummer, Blockeintrag eintrag) {
         this.rundenNummer = rundenNummer;
-        this.eintraege = new ArrayList<>();
+        this.eintraege = new Blockeintrag[spielerAnzahl];
-        addEintrag(eintrag);
     }
+
     /*------------------------------------------*/
     // statische Methoden
     /*------------------------------------------*/
@@ -45,13 +39,7 @@ public class Blockzeile {
     /*------------------------------------------*/
     // Getter und Setter
     /*------------------------------------------*/
-    public int getRundenNummer() {
-        return rundenNummer;
-    }
 
-    public void setRundenNummer(int rundenNummer) {
-        this.rundenNummer = rundenNummer;
-    }
     /*------------------------------------------*/
     // @Overrides
     /*------------------------------------------*/
@@ -60,27 +48,21 @@ public class Blockzeile {
     // öffentliche Methodes
     /*------------------------------------------*/
 
-    public void addEintrag(Blockeintrag eintrag) {
+    public void addEintrag(Blockeintrag be) {
-        if(eintraege != null){
+
-            eintraege.add(eintrag);
+        for (int i = 0; i < eintraege.length; i++) {
+            if (eintraege[i] == null) {
+                eintraege[i] = be;
+            }
         }
     }
 
     public Blockeintrag[] getDaten() {
-        return eintraege.toArray(new Blockeintrag[0]);
+        return eintraege;
     }
+
     /*------------------------------------------*/
     // 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

@@ -9,17 +9,17 @@ 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

@@ -1,13 +0,0 @@
-/*
-============================================================
-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

@@ -1,65 +0,0 @@
-/*
-============================================================
-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

@@ -1,15 +0,0 @@
-/*
-============================================================
-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,31 +9,28 @@ package Domain.Karten;
 public abstract class Karte {
 
 	// Statische Konstanten
-
+	
 	// Statische Attribute
-	private int id;
+	private static int id_card = 0;
 	// Attribute des Ojektes
-
+	
+	
 	// Konstruktoren
 	public Karte() {
-
+		if (id_card < 60) {
+			id_card++;
+		}
 	}
-
-	public Karte(int id) {
-		this.id = id;
-	}
-
 	// Statische Methoden
-
+	
 	// Getter und Setter
-
+	public int getId_card() {
-	public int getId() {
+		return id_card;
-		return this.id;
 	}
-
+	
 	// @Overrides
-
+	
 	// Public Methoden (öffentliche Methoden)
-
+	
 	// Private Methoden (Hilfsmethoden)
 }

Domain/Karten/Magierkarte.java

@@ -6,47 +6,37 @@ written on: 05 / 10 / 2023 at: 23:41
 */
 package Domain.Karten;
 
-import Domain.Enums.Kartenfarbe;
-
 public class Magierkarte extends Karte {
 
 	// Statische Konstanten
-	private final static String NAME = "Zauberer";
+	private static String KARTENNAME = "Zauberer";
 	// Statische Attribute
 
 	// Attribute des Objekts
-	
 	private String name;
-	
 	// Konstruktoren
 
-	public Magierkarte(int id) {
+	public Magierkarte() {
-		super(id);
+		super();
-		setName();
+		setName(KARTENNAME);
-
 	}
 
 	// Statische Methoden
 
 	// Getter und Setter
 
-	public int getId() {
+	public void setName(String name) {
-		return super.getId();
+		this.name = name;
-	}
-
-	private void setName() {
-		this.name = NAME;
 	}
 
 	public String getName() {
 		return this.name;
 	}
 
-
 	// @Overrides
 	@Override
 	public String toString() {
-		return "ID " + this.getId() +  ": " + this.getName();
+		return this.getName();
 	}
 	// Public Methoden
 

Domain/Karten/Narrenkarte.java

@@ -6,48 +6,37 @@ written on: 05 / 10 / 2023 at: 23:41
 */
 package Domain.Karten;
 
-import Domain.Enums.Kartenfarbe;
-
 public class Narrenkarte extends Karte {
 
 	// Statische Konstanten
-	private final static String NAME = "Narr";
+	private static String KARTENNAME = "Narr";
 	// Statische Attribute
 
 	// Attribute des Objekts
-	
 	private String name;
 	// Konstruktoren
 
-	public Narrenkarte(int id) {
+	public Narrenkarte() {
-		super(id);
+		super();
-		setName();
+		setName(KARTENNAME);
-
 	}
+
 	// Statische Methoden
 
 	// Getter und Setter
-	
-	public int getId() {
-		return super.getId();
-	}
 
-	private void setName() {
+	public void setName(String name) {
-		this.name = NAME;
+		this.name = name;
 	}
 
 	public String getName() {
 		return this.name;
 	}
 
-	public void setNarrenkarteanzahl(int narrenkarteanzahl) {
-		narrenkarteanzahl++;
-	}
-
 	// @Overrides
 	@Override
 	public String toString() {
-		return "ID " + this.getId() + ": " + this.getName();
+		return this.getName();
 	}
 	// Public Methoden
 

Domain/Karten/Zahlenkarte.java

@@ -13,7 +13,7 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// statische Konstanten
 	/*------------------------------------------*/
-
+	private final static String KARTENNAME = "Charakterkarte";
 	/*------------------------------------------*/
 	// statische Attribute(zB. zähler)
 	/*------------------------------------------*/
@@ -21,20 +21,22 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// Attribute jedes Objektes
 	/*------------------------------------------*/
-	private Kartenfarbe farbe;
+	private Kartenfarbe kartenfarbe;
 	private int kartenNummer;
+	private String name;
 
 	/*------------------------------------------*/
 	// Konstruktoren (default und spezifische)
 	/*------------------------------------------*/
-	public Zahlenkarte(int id) {
+	public Zahlenkarte() {
-		super(id);
+		super();
 	}
 
-	public Zahlenkarte(int id, Kartenfarbe farbe, int kartenNummer) {
+	public Zahlenkarte(Kartenfarbe kartenfarbe, int kartenNummer) {
-		super(id);
+		super();
-		setFarbe(farbe);
+		setKartenfarbe(kartenfarbe);
 		setKartenNummer(kartenNummer);
+		setName(KARTENNAME);
 
 	}
 	/*------------------------------------------*/
@@ -44,17 +46,12 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// Getter und Setter
 	/*------------------------------------------*/
-	
+	public void setKartenfarbe(Kartenfarbe kartenfarbe) {
-	public int getId() {
+		this.kartenfarbe = kartenfarbe;
-		return super.getId();
-	}
-	
-	public void setFarbe(Kartenfarbe farbe) {
-		this.farbe = farbe;
 	}
 
-	public Kartenfarbe getFarbe() {
+	public Kartenfarbe getKartenfarbe() {
-		return farbe;
+		return kartenfarbe;
 	}
 
 	public void setKartenNummer(int kartenNummer) {
@@ -64,11 +61,20 @@ public class Zahlenkarte extends Karte {
 	public int getKartenNummer() {
 		return kartenNummer;
 	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public String getName() {
+		return this.name;
+	}
 
 	/*------------------------------------------*/
 	// @Overrides
 	/*------------------------------------------*/
-
+	@Override
+	public String toString() {
+		return "Charakterkarte: " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe() + ").";
+	}
 	/*------------------------------------------*/
 	// öffentliche Methodes
 	/*------------------------------------------*/
@@ -77,4 +83,4 @@ public class Zahlenkarte extends Karte {
 	// Hilfsmethoden (privat)
 	/*------------------------------------------*/
 
-}
+}

Domain/Kartenstapel.java

@@ -6,142 +6,113 @@ 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.*;
 
+import Domain.Enums.Kartenfarbe;
+import Domain.Karten.Karte;
+import Domain.Karten.Magierkarte;
+import Domain.Karten.Narrenkarte;
+import Domain.Karten.Zahlenkarte;
 
 public class Kartenstapel {
 
-	// Statische Konstanten
+	/*------------------------------------------*/
-
+	// statische Konstanten
-	// Statische Attribute
+	/*------------------------------------------*/
-	private static int kartenzählen = 1;
-	// Attribute der Objekte
 	
+	/*------------------------------------------*/
+	// statische Attribute(zB. zähler)
+	/*------------------------------------------*/
+	private static int kartenzähler = 1;
+	/*------------------------------------------*/
+	// Attribute jedes Objektes
+	/*------------------------------------------*/
 	/**
-	 * Die HashMap besitzt alle Karten in sortierter Reihenfolge Die ArrayList wird
+	 * Die beiden HashMaps repräsentieren das Kartendeck einmal
-	 * durch Zufall erzeugt und gibt den Key der HashMap wieder. D.h.
+	 * sortiert und gemischt
 	 */
 	private HashMap<Integer, Karte> kartensortiert = new HashMap<>();
-
 	private HashMap<Integer, Karte> kartengemischt = new HashMap<>();
 
-	// Konstruktoren
+	/*------------------------------------------*/
+	// Konstruktoren (default und spezifische)
+	/*------------------------------------------*/
+	
+	// Der Konstruktor PRIVATE? Weil darf nur von Spiel aufgerufen werden?
+	
+	/**
+	 * Bei jedem Aufruf des Konstruktors wird die HashMap gelöscht und
+	 * sortiert neu befüllt.
+	 * Die tatsächliche Reihenfolge spielt keine Rolle, da die Karten selbst
+	 * NUR über den KEY identifiziert werden.
+	 */
 	public Kartenstapel() {
 		kartensortiert.clear();
 		// Erstelle Magierkarten
 		for (int i = 1; i <= 4; i++) {
-			kartensortiert.put(i, new Magierkarte(i));
+			kartensortiert.put(i, new Magierkarte());
 		}
-		// Erstelle Narrenkarten
 		for (int i = 5; i <= 8; i++) {
-			kartensortiert.put(i, new Narrenkarte(i));
+			kartensortiert.put(i,  new Narrenkarte());
 		}
-		// Erstelle Charakterkarten MENSCH
 		for (int i = 9; i <= 21; i++) {
-			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8));
+			kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.MENSCH, i));
 		}
-		// Erstelle Charakterkarten ELF
 		for (int i = 22; i <= 34; i++) {
-			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ELF, i - 21));
+			kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.ELF, i));
 		}
-		// Erstelle Charakterkarten RIESE
 		for (int i = 35; i <= 47; i++) {
-			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.RIESE, i - 34));
+			kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.RIESE, i));
 		}
-		// Erstelle Charakterkarten ZWERG
 		for (int i = 48; i <= 60; i++) {
-			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
+			kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.ZWERG, i));
-		}
+		}	
-
-	
 	}
-	// Statische Methoden
+	/*------------------------------------------*/
+	// statische Methoden
+	/*------------------------------------------*/
 
+	/*------------------------------------------*/
 	// Getter und Setter
-	public Karte getKartesortiert(Integer index) {
+	/*------------------------------------------*/
-		return kartensortiert.get(index);
+	
-	}
+	/*------------------------------------------*/
-	// Overrides
+	// @Overrides
-
+	/*------------------------------------------*/
-	// Public Methoden
+	
+	/*------------------------------------------*/
+	// öffentliche Methoden
+	/*------------------------------------------*/
+	
 	/**
-	 * Die Collection der HashMap 'kartensortiert'.
+	 * Die BEIDEN Collections dienen zu TESTZWECKEN
-	 * 
-	 * @return Die Kartenreferenzen der HashMap.
 	 */
-	public Collection<Karte> getKartenstapelSortiert() {
+	public Collection<Karte> getKartensortiert() {
 		return kartensortiert.values();
 	}
-
+	public Collection<Karte> getKartengemischt() {
-	public Collection<Karte> getKartenstapelGemischt() {
 		return kartengemischt.values();
 	}
-
+	
 	/**
-	 * Methode für die Testklasse KartenstapelTest, um die Sortierung Visuell zu
+	 * Methode: mischen()
-	 * bestätigen. Kann nach Finalem Test und Freigabe gelöscht oder auskommentiert
+	 * Eine ArrayList mit 60 Nummern wird erzeugt.
-	 * werden.
+	 * Eine for-Schleife zieht jeweils eine Nummer.
-	 * 
+	 * Diese wird aus 'kartensortiert' gezogen und
-	 * @return 'kg' Eine Namensliste des gemischten Kartenstapel
+	 * in 'kartengemischt' einsortiert.
-	 */
+	 * Danach wird die Nummer aus der ArrayList gelöscht
-	public HashMap<Integer, String> getStatusGemischt() {
+	 * und es wird erneut eine Nummer aus den verblieben Zahlen
-		HashMap<Integer, String> kg = new HashMap<>();
+	 * gezogen.
-		for (int i = 1; i <= 60; i++) {
-			kg.put(i, ((String) kartengemischt.get(i).toString()));
-		}
-		return kg;
-	}
-
-	/**
-	 * 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);
-		}
 		
-		for(Karte k : kartengemischt.values()) {
-			System.out.println(k.toString());
-		}
 	}
 
-	/**
+	/*------------------------------------------*/
-	 * Methode getObersteKarte(): Hier wird der Reihe nach die jeweils oberste Karte
+	// Hilfsmethoden (privat)
-	 * 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 extends Object implements Serializable {
+public class Spieler implements Serializable {
 
 	/*------------------------------------------*/
 	// statische Konstanten
@@ -27,7 +27,6 @@ public class Spieler extends Object implements Serializable {
 	private String name;
 	private int vorhersage;
 	private Geschlecht geschlecht;
-	//
 
 	/*------------------------------------------*/
 	// Konstruktoren (default und spezifische)
@@ -36,7 +35,7 @@ public class Spieler extends Object implements Serializable {
 	/**
 	 * Default Konstruktor des Spieler - Klasse
 	 */
-	public Spieler() {
+	Spieler() {
 
 	}
 
@@ -47,21 +46,24 @@ public class Spieler extends Object implements Serializable {
 	 * @param name       String
 	 * @param geschlecht Geschlecht
 	 */
-	public Spieler(int id, String name, Geschlecht geschlecht) {
+	Spieler(int id, String name, Geschlecht geschlecht) {
 		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);
+			setGeschlecht(geschlecht);	
 	}
 
 	/**
@@ -73,7 +75,7 @@ public class Spieler extends Object implements Serializable {
 	 * @param geschlecht Geschlecht
 	 * @param vorhersage int
 	 */
-	public Spieler(int id, String name, Geschlecht geschlecht, int vorhersage) {
+	Spieler(int id, String name, Geschlecht geschlecht, int vorhersage) {
 		this(id, name, geschlecht);
 		setVorhersage(vorhersage);
 	}
@@ -120,7 +122,7 @@ public class Spieler extends Object implements Serializable {
 	 * @return String name
 	 */
 	public String getName() {
-		return this.name;
+		return name;
 	}
 
 	// geschlecht

Domain/Stich.java

@@ -1,82 +0,0 @@
-/*
-============================================================
-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,12 +11,8 @@ 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 {
 
@@ -24,11 +20,6 @@ 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)
     /*--------------------------------------------------------*/
@@ -42,7 +33,6 @@ 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;
@@ -56,7 +46,6 @@ public class Spiel implements Serializable {
         this.istBeendet = false;
         this.spielerAmZug = null;
         this.runde = 0;
-        this.kartenstapel = new Kartenstapel();
     };
     /*--------------------------------------------------------*/
     // statische Methoden
@@ -88,34 +77,8 @@ public class Spiel implements Serializable {
 
     @Override
     public String toString() {
-        String text = "\n";
+        return "Runde: " + getRunde() + ", Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + ", Beendet: "
-        String header = "Systemausgabe--------------------------------\n";
+                + (istSpielBeendet() ? "Ja" : "Nein") + ", Spieler am Zug: " + getSpielerAmZug()[0];
-        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;
     }
 
     /*--------------------------------------------------------*/
@@ -127,69 +90,25 @@ 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) throws SpielerNotFoundException, EmptyListException, RuntimeException {
+    public void removeSpieler(int id_spieler) {
-        if (this.spieler.containsKey(id_spieler)) {
+        this.spieler.remove(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()];
-        int zähler = 0;
+        for (int i = 0; i < this.spieler.size() - 1; i++) {
-        for (Spieler s : this.spieler.values()) {
+            spieler_text[i] = this.spieler.get(i).toString();
-            spieler_text[zähler] = s.toString();
-            zähler++;
         }
         return spieler_text;
     }
 
     public void starteSpiel() {
-        // sing genügend Spieler angelegt?
+        this.istGestartet = true;
-        if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
+        // Gameloop?
-            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() {
@@ -222,13 +141,6 @@ 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) {
@@ -243,22 +155,4 @@ 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

@@ -1,29 +0,0 @@
-/*
-============================================================
-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,96 +6,6 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-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,39 +6,6 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-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,102 +6,6 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-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

@@ -6,35 +6,41 @@ written on: 10 / 10 / 2023 at: 21:18
 */
 package Test.Domain.Karten;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertEquals; 
-import static org.junit.Assert.assertTrue;
+import org.junit.Test; 
-
+import Domain.Enums.Kartenfarbe;
-import org.junit.Test;
 import Domain.Karten.Magierkarte;
 
+/**
+ * 
+ * @author sellm
+ * @version
+ * 
+ *
+ */
 
 public class MagierkarteTest {
 
-	
 	@Test
 	public void vierMagier() {
-		Magierkarte m1 = new Magierkarte(1);
+		Magierkarte m1 = new Magierkarte();
-		Magierkarte m2 = new Magierkarte(2);
+		Magierkarte m2 = new Magierkarte();
-		Magierkarte m3 = new Magierkarte(3);
+		Magierkarte m3 = new Magierkarte();
-		Magierkarte m4 = new Magierkarte(4);
+		Magierkarte m4 = new Magierkarte();
-
+		
 		
 		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());
+		assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());
-
+		
 	}
-
+	
 }

Test/Domain/Karten/NarrenkarteTest.java

@@ -7,33 +7,23 @@ 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 n1 = new Narrenkarte();
-		Narrenkarte n2 = new Narrenkarte(6);
+		Narrenkarte n2 = new Narrenkarte();
-		Narrenkarte n3 = new Narrenkarte(7);
+		Narrenkarte n3 = new Narrenkarte();
-		Narrenkarte n4 = new Narrenkarte(8);
+		Narrenkarte n4 = new Narrenkarte();
 
 		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

@@ -7,81 +7,89 @@ 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
+	 * Die Objekterzeugung der HashMap und der Zahlenkarten
-	public void zahlenkartentesten() {
+	 * kann auch in ein @BeforeAll eingetragen werden.
-		
+	 */
-		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());
-		
-		
-		
-	}	
-		
 
+	/**
+	 * 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);
+		}
+
+		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);
+	}
+
+	@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);
+		}
+
+		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,6 +8,8 @@ package Test.Domain;
 
 import org.junit.Test;
 
+import static org.junit.Assert.assertEquals;
+
 public class KartenstapelTest {
 
     @Test

UI/SpielCLI.java

@@ -8,20 +8,11 @@ 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;
 
@@ -31,15 +22,13 @@ public class SpielCLI {
     }
 
     public void hauptmenue() {
-        System.out.println("Hallo Wanderer");
         mainloop: while (true) {
-            print("");
+            System.out.println("Hallo Wanderer");
-            print("--------Hauptmenü--------");
+            System.out.println("Was sillst du tun");
-            print(ANSI_BLUE + "-1-" + ANSI_RESET + " Spiel starten");
+            System.out.println("--------Hauptmenü--------");
-            print(ANSI_BLUE + "-2-" + ANSI_RESET + " Spieler hinzufügen");
+            System.out.println("-1- Spiel starten");
-            print(ANSI_BLUE + "-3-" + ANSI_RESET + " Spiel to String");
+            System.out.println("-2- Spiel to String");
-            print(ANSI_BLUE + "-4-" + ANSI_RESET + " Spieler löschen");
+            System.out.println("-3- Exit");
-            print(ANSI_BLUE + "-5-" + ANSI_RESET + " Exit");
 
             int input = 0;
 
@@ -51,18 +40,12 @@ public class SpielCLI {
 
             switch (input) {
                 case 1:
-                    spielStarten();
+                    System.out.println("Noch nicht implementiert.");
                     break;
                 case 2:
-                    addSpieler();
-                    break;
-                case 3:
                     System.out.println(spiel.toString());
                     break;
-                case 4:
+                case 3:
-                    spielerLöschen();
-                    break;
-                case 5:
                     break mainloop;
                 case 0:
                     System.out.println("Diese eingabe ist nicht vergeben.");
@@ -71,96 +54,4 @@ 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);
-    }
-
 }