lokal merge; SpielCLI -> Spieler hinzufügen mit switch ob es genügend sind.

Domain/Karten/Magierkarte.java

@@ -13,26 +13,23 @@ public class Magierkarte extends Karte {
 	// Statische Konstanten
 
 	// Statische Attribute
-	private static int magierkartenanzahl = 0;
+
 	// Attribute des Objekts
 	private Kartenfarbe kartenfarbe;
 	private String bezeichnung;
+	private static int magierkartenanzahl = 0;
 	// Konstruktoren
 
 	public Magierkarte() {
 		super();
-		setMagierkartenanzahl(magierkartenanzahl);
+
 	}
 
 	public Magierkarte(Kartenfarbe kartenfarbe, String bezeichnung) {
 		super();
-		if (magierkartenanzahl < 4) {
+		setKartenfarbe(kartenfarbe);
-			setMagierkartenanzahl(magierkartenanzahl);
+		setBezeichnung(bezeichnung);
-			setKartenfarbe(kartenfarbe);
+
-			setBezeichnung(bezeichnung);
-		} else {
-			throw new RuntimeException("Es darf nur vier Magier im Spiel geben.");
-		}
 	}
 
 	// Statische Methoden

Domain/Karten/Narrenkarte.java

@@ -13,7 +13,7 @@ public class Narrenkarte extends Karte {
 	// Statische Konstanten
 
 	// Statische Attribute
-	private static int narrenkarteanzahl = 0;
+
 	// Attribute des Objekts
 	private Kartenfarbe farbe;
 	private String bezeichnung;
@@ -25,13 +25,9 @@ public class Narrenkarte extends Karte {
 
 	public Narrenkarte(Kartenfarbe farbe, String bezeichnung) {
 		super();
-		if (narrenkarteanzahl < 4) {
+		setFarbe(farbe);
-			setNarrenkarteanzahl(narrenkarteanzahl);
+		setBezeichnung(bezeichnung);
-			setFarbe(farbe);
+
-			setBezeichnung(bezeichnung);
-		} else {
-			throw new RuntimeException("Es darf nur vier Narrenkarten geben.");
-		}
 	}
 	// Statische Methoden
 

Domain/Karten/Zahlenkarte.java

@@ -6,62 +6,70 @@ written on: 05 / 10 / 2023 at: 23:30
 */
 package Domain.Karten;
 
+import Domain.Enums.Kartenfarbe;
+
 public class Zahlenkarte extends Karte {
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // statische Konstanten
+	// statische Konstanten
-    /*------------------------------------------*/
+	/*------------------------------------------*/
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // statische Attribute(zB. zähler)
+	// statische Attribute(zB. zähler)
-    /*------------------------------------------*/
+	/*------------------------------------------*/
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // Attribute jedes Objektes
+	// Attribute jedes Objektes
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    private int wert;
+	private Kartenfarbe farbe;
+	private int kartenNummer;
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // Konstruktoren (default und spezifische)
+	// Konstruktoren (default und spezifische)
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    public Zahlenkarte() {
+	public Zahlenkarte() {
+		super();
+	}
 
-    }
+	public Zahlenkarte(Kartenfarbe farbe, int kartenNummer) {
+		super();
+		setFarbe(farbe);
+		setKartenNummer(kartenNummer);
 
-    public Zahlenkarte(int wert) {
+	}
-        setWert(wert);
+	/*------------------------------------------*/
-    }
+	// statische Methoden
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // statische Methoden
-    /*------------------------------------------*/
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // Getter und Setter
+	// Getter und Setter
-    /*------------------------------------------*/
+	/*------------------------------------------*/
+	public void setFarbe(Kartenfarbe farbe) {
+		this.farbe = farbe;
+	}
 
-    public int getWert() {
+	public Kartenfarbe getFarbe() {
-        return this.wert;
+		return farbe;
-    }
+	}
 
-    public void setWert(int wert) {
+	public void setKartenNummer(int kartenNummer) {
-        this.wert = wert;
+		this.kartenNummer = kartenNummer;
-    }
+	}
 
-    /*------------------------------------------*/
+	public int getKartenNummer() {
-    // @Overrides
+		return kartenNummer;
-    /*------------------------------------------*/
+	}
 
-    @Override
+	/*------------------------------------------*/
-    public String toString() {
+	// @Overrides
-        return "Zahlenkarte [Wert: " + getWert() + ", ID: " + this.getId() + " ]";
+	/*------------------------------------------*/
-    }
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // öffentliche Methodes
+	// öffentliche Methodes
-    /*------------------------------------------*/
+	/*------------------------------------------*/
 
-    /*------------------------------------------*/
+	/*------------------------------------------*/
-    // Hilfsmethoden (privat)
+	// Hilfsmethoden (privat)
-    /*------------------------------------------*/
+	/*------------------------------------------*/
 
 }

Domain/Spieler.java

@@ -109,7 +109,7 @@ public class Spieler implements Serializable {
 	 * @return String name
 	 */
 	public String getName() {
-		return name;
+		return this.name;
 	}
 
 	// geschlecht

Facade/Spiel.java

@@ -79,8 +79,25 @@ public class Spiel implements Serializable {
 
     @Override
     public String toString() {
-        return "Runde: " + getRunde() + ", Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + ", Beendet: "
+        String text = "\n";
-                + (istSpielBeendet() ? "Ja" : "Nein") + ", Spieler am Zug: " + getSpielerAmZug()[0];
+        String header = "Systemausgabe--------------------------------\n";
+        String footer = "---------------------------------------------\n";
+        text += header;
+        text += "Runde: " + getRunde() + "\n";
+        text += "Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + "\n";
+        text += "Beendet: " + (istSpielBeendet() ? "Ja" : "Nein") + "\n";
+        text += "Spieler am Zug: "
+                + (this.spielerAmZug == null ? "Noch keine Spieler vorhanden" : this.spielerAmZug.getName()) + "\n";
+        if (this.spieler.size() == 0) {
+            text += "Noch keine Spieler vorhanden \n";
+        } else {
+            for (int i = 0; i < this.spieler.size(); i++) {
+                text += "Spieler " + (i + 1) + ": " + this.spieler.get(i + 1).getName() + " ("
+                        + this.spieler.get(i + 1).getGeschlecht() + ")" + "\n";
+            }
+        }
+        text += footer;
+        return text;
     }
 
     /*--------------------------------------------------------*/
@@ -92,8 +109,10 @@ 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));
     }
 
     public void removeSpieler(int id_spieler) {

Test/Domain/Karten/MagierkarteTest.java

@@ -45,12 +45,4 @@ public class MagierkarteTest {
 		
 	}
 	
-	public void magierAnzahl() {
-		Magierkarte m1 = new Magierkarte(Kartenfarbe.MENSCH, "Zauberer");
-		Magierkarte m2 = new Magierkarte(Kartenfarbe.ELF, "Zauberer");
-		Magierkarte m3 = new Magierkarte(Kartenfarbe.RIESE, "Zauberer");
-		Magierkarte m4 = new Magierkarte(Kartenfarbe.ZWERG, "Zauberer");
-		
-		assertThrows(RuntimeException.class, () -> { Magierkarte m5 = new Magierkarte(Kartenfarbe.MENSCH, "Zauberer");});
-	}
 }

Test/Domain/Karten/NarrenkarteTest.java

@@ -38,13 +38,4 @@ public class NarrenkarteTest {
 		assertEquals(Kartenfarbe.RIESE.getFarbe(), "GELB");
 		assertEquals(Kartenfarbe.ZWERG.getFarbe(), "ROT");
 	}
-	
-	public void Narrenanzahl() {
-		Narrenkarte n1 = new Narrenkarte(Kartenfarbe.MENSCH, "Narr");
-		Narrenkarte n2 = new Narrenkarte(Kartenfarbe.ELF, "Narr");
-		Narrenkarte n3 = new Narrenkarte(Kartenfarbe.RIESE, "Narr");
-		Narrenkarte n4 = new Narrenkarte(Kartenfarbe.ZWERG, "Narr");
-		
-		assertThrows(RuntimeException.class, () -> {Narrenkarte n5 = new Narrenkarte(Kartenfarbe.MENSCH, "Narr");});
-	}
 }

Test/Domain/Karten/ZahlenkarteTest.java

@@ -6,6 +6,90 @@ written on: 10 / 10 / 2023 at: 21:18
 */
 package Test.Domain.Karten;
 
+import static org.junit.Assert.assertEquals;
+
+import java.util.HashMap;
+
+import org.junit.Test;
+
+import Domain.Enums.Kartenfarbe;
+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).getFarbe(), Kartenfarbe.MENSCH);
+		assertEquals(zm.get(7).getKartenNummer(), 7);
+
+		assertEquals(zm.get(4).getFarbe(), 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).getFarbe(), Kartenfarbe.ELF);
+		assertEquals(ze.get(7).getKartenNummer(), 7);
+
+		assertEquals(ze.get(4).getFarbe(), 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).getFarbe(), Kartenfarbe.ZWERG);
+		assertEquals(zz.get(7).getKartenNummer(), 7);
+
+		assertEquals(zz.get(4).getFarbe(), 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).getFarbe(), Kartenfarbe.RIESE);
+		assertEquals(zr.get(9).getKartenNummer(), 9);
+
+		assertEquals(zr.get(2).getFarbe(), Kartenfarbe.RIESE);
+		assertEquals(zr.get(2).getKartenNummer(), 2);
+	}
 }

UI/SpielCLI.java

@@ -8,6 +8,8 @@ written on: 05 / 10 / 2023 at: 23:25
 package UI;
 
 import Facade.Spiel;
+import Domain.Spieler;
+import Domain.Enums.Geschlecht;
 
 import java.util.Scanner;
 
@@ -22,13 +24,15 @@ public class SpielCLI {
     }
 
     public void hauptmenue() {
+        System.out.println("Hallo Wanderer");
         mainloop: while (true) {
-            System.out.println("Hallo Wanderer");
+            System.out.println("");
             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("-2- Spieler hinzufügen");
-            System.out.println("-3- Exit");
+            System.out.println("-3- Spiel to String");
+            System.out.println("-4- Exit");
 
             int input = 0;
 
@@ -44,9 +48,35 @@ public class SpielCLI {
                     System.out.println("Noch nicht implementiert.");
                     break;
                 case 2:
+                    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;
+
+                    }
+                    break;
+
+                case 3:
                     System.out.println(spiel.toString());
                     break;
-                case 3:
+                case 4:
                     break mainloop;
                 case 0:
                     System.out.println("Diese eingabe ist nicht vergeben.");