megre with recent pull and further changes

Domain/Enums/Kartenfarbe.java

@@ -20,4 +20,9 @@ public enum Kartenfarbe {
 		return farbe;
 	}
 
+	@Override
+	public String toString() {
+		return getFarbe();
+	}
+
 }

Domain/Karten/Magierkarte.java

@@ -63,13 +63,13 @@ public class Magierkarte extends Karte {
 	public int getMagierkartenanzahl() {
 		return magierkartenanzahl;
 	}
-	// @Overrides
 
+	// @Overrides
 	@Override
 	public String toString() {
-		return "Magierkarte [ID: " + this.getId() + " ]";
+		return this.getBezeichnung() + ": " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe().toString()
+				+ ").";
 	}
-
 	// Public Methoden
 
 	// Private Methoden

Domain/Karten/Narrenkarte.java

@@ -15,7 +15,7 @@ public class Narrenkarte extends Karte {
 	// Statische Attribute
 
 	// Attribute des Objekts
-	private Kartenfarbe farbe;
+	private Kartenfarbe kartenfarbe;
 	private String bezeichnung;
 	// Konstruktoren
 
@@ -25,7 +25,7 @@ public class Narrenkarte extends Karte {
 
 	public Narrenkarte(Kartenfarbe farbe, String bezeichnung) {
 		super();
-		setFarbe(farbe);
+		setKartenfarbe(farbe);
 		setBezeichnung(bezeichnung);
 
 	}
@@ -36,12 +36,12 @@ public class Narrenkarte extends Karte {
 		return this.getId();
 	}
 
-	public void setFarbe(Kartenfarbe farbe) {
+	public void setKartenfarbe(Kartenfarbe farbe) {
-		this.farbe = farbe;
+		this.kartenfarbe = farbe;
 	}
 
-	public Kartenfarbe getFarbe() {
+	public Kartenfarbe getKartenfarbe() {
-		return this.farbe;
+		return this.kartenfarbe;
 	}
 
 	public void setBezeichnung(String bezeichnung) {
@@ -55,13 +55,13 @@ public class Narrenkarte extends Karte {
 	public void setNarrenkarteanzahl(int narrenkarteanzahl) {
 		narrenkarteanzahl++;
 	}
-	// @Overrides
 
+	// @Overrides
 	@Override
 	public String toString() {
-		return "Narrenkarte [ID: " + this.getId() + " ]";
+		return this.getBezeichnung() + ": " + this.getKartenfarbe().name() + " (" + this.getKartenfarbe().toString()
+				+ ").";
 	}
-
 	// Public Methoden
 
 	// Private Methoden

Domain/Karten/Zahlenkarte.java

@@ -22,7 +22,7 @@ public class Zahlenkarte extends Karte {
 	// Attribute jedes Objektes
 	/*------------------------------------------*/
 	private Kartenfarbe farbe;
-	private int wert;
+	private int kartenNummer;
 
 	/*------------------------------------------*/
 	// Konstruktoren (default und spezifische)
@@ -31,10 +31,10 @@ public class Zahlenkarte extends Karte {
 		super();
 	}
 
-	public Zahlenkarte(Kartenfarbe farbe, int wert) {
+	public Zahlenkarte(Kartenfarbe farbe, int kartenNummer) {
 		super();
 		setFarbe(farbe);
-		setWert(wert);
+		setKartenNummer(kartenNummer);
 
 	}
 	/*------------------------------------------*/
@@ -52,12 +52,12 @@ public class Zahlenkarte extends Karte {
 		return farbe;
 	}
 
-	public void setWert(int kartenNummer) {
+	public void setKartenNummer(int kartenNummer) {
-		this.wert = kartenNummer;
+		this.kartenNummer = kartenNummer;
 	}
 
-	public int getWert() {
+	public int getKartenNummer() {
-		return wert;
+		return kartenNummer;
 	}
 
 	/*------------------------------------------*/

Domain/Spieler.java

@@ -23,10 +23,11 @@ public class Spieler extends Object implements Serializable {
 	/*------------------------------------------*/
 	// Attribute jedes Objektes
 	/*------------------------------------------*/
-	private int id;
+	private int id = 0;
 	private String name;
 	private int vorhersage;
 	private Geschlecht geschlecht;
+	//
 
 	/*------------------------------------------*/
 	// Konstruktoren (default und spezifische)
@@ -48,8 +49,18 @@ public class Spieler extends Object implements Serializable {
 	 */
 	public Spieler(int id, String name, Geschlecht geschlecht) {
 		this();
+		if (id < 6) {
 			setId(id);
-		setName(name);
+		} else {
+			throw new RuntimeException("Es darf nur max 6 Spieler geben.");
+		}
+		if (geschlecht == Geschlecht.KI) {
+			setName(name); // Bei KI wird kein Name gesetzt. name = leerer String
+		} else if (name.length() > 2) {
+			setName(name); // Es wird geprüft, ob Name größer 2 Zeichen
+		} else {
+			throw new RuntimeException("Der Name muss länger als 2 Buchstaben sein.");
+		}
 		setGeschlecht(geschlecht);
 	}
 

Domain/Stich.java

@@ -21,17 +21,17 @@ public class Stich {
     // Attribute jedes Objektes
     /*------------------------------------------*/
     private Karte[] karten;
+    private int[] spielerID;
+    private int kartenCount = 0;
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
 
     public Stich() {
-
     }
 
-    public Stich(Karte[] karten) {
+    public Stich(int spielerAnzahl) {
-        setKarten(karten);
+        setSpielerAnzahl(spielerAnzahl);
-
     }
 
     /*------------------------------------------*/
@@ -42,14 +42,21 @@ public class Stich {
     // Getter und Setter
     /*------------------------------------------*/
 
-    public void setKarten(Karte[] karten) {
+    public void setSpielerAnzahl(int spielerAnzahl) {
-        this.karten = karten;
+        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
     /*------------------------------------------*/

Facade/Spiel.java

@@ -42,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;
@@ -164,31 +165,31 @@ public class Spiel implements Serializable {
         // sing genügend Spieler angelegt?
         if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
             this.istGestartet = true;
-        } else {
-            System.out.println("Es fehlen " + (3 - this.spieler.size()) + " spieler");
-        }
-
             while (!this.istSpielBeendet()) {
                 System.out.println("Das Spiel wurde gestartet.");
 
                 // Beginn der Runde
                 // Stiche erstellen
                 erstelleStiche(this.runde);
-            // Karten verteilen
+                // 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");
+        }
 
-        // Die Karten sind verteilt
-
-        // Für jeden Spieler Karten ausspielen und im Stich speichern
-
-        // ermitteln welcher Spieler gewonnen hat
-
-        // Stich beim Spieler speichern
-
-        // Gameloop?
     }
 
     public String[] getSpielerAmZug() {
@@ -242,8 +243,10 @@ public class Spiel implements Serializable {
     // Hilfsmethoden (privat)
     /*--------------------------------------------------------*/
 
-    private Stich[] erstelleStiche(int runde) {
+    private void erstelleStiche(int runde) {
-        return new Stich[runde];
+        for (int i = 0; i < runde; i++) {
+            this.stiche.put(i + 1, new Stich(this.spieler.size()));
+        }
     }
 
     private void ermittleGewinner(Stich stich) {

RendomTest.java

@@ -8,10 +8,22 @@ written on: 20 / 10 / 2023 at: 08:26
 import java.util.Random;
 
 public class RendomTest {
-    public static void main(String[] args) {
+
-        Random r = new Random();
+    // ----------------------------- Spiel
-        int high = 10;
+    // ausspiele(int Kartenid){
-        int low = 1;
+    // Karte temp = Spieler.getKarte(id)
-        System.out.println(r.nextInt(high - low) + low);
+    // Stich.add(spielerAmZug.getId(), temp);
-    }
+    // }
+
+    // ------------------------------Stich
+    // Trumpf: Mensch
+    // spielerID: [3, 4, 1, 2]
+    // Karten: [Zwerg 4, Magier, narr, Magie]
+    //
+    // wo sind magier, false, true
+    // Karte -> Karten[1]
+    // Spieler -> spielerID[1]
+    //
+    // private void add(int Spielerid, int Kartenid){}
+    // spieler
 }

Test/Domain/Karten/MagierkarteTest.java

@@ -21,6 +21,14 @@ import org.junit.Test;
 import Domain.Enums.Kartenfarbe;
 import Domain.Karten.Magierkarte;
 
+/**
+ * 
+ * @author sellm
+ * @version
+ * 
+ *
+ */
+
 public class MagierkarteTest {
 
 	@Test
@@ -43,6 +51,8 @@ public class MagierkarteTest {
 		assertEquals("Zauberer", m4.getBezeichnung());
 		assertEquals("ROT", Kartenfarbe.ZWERG.getFarbe());
 		
+		assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());
+		
 	}
 	
 }

Test/Domain/Karten/NarrenkarteTest.java

@@ -23,10 +23,10 @@ public class NarrenkarteTest {
 		Narrenkarte n3 = new Narrenkarte(Kartenfarbe.RIESE, "Narr");
 		Narrenkarte n4 = new Narrenkarte(Kartenfarbe.ZWERG, "Narr");
 		
-		assertEquals(n1.getFarbe(), Kartenfarbe.MENSCH);
+		assertEquals(n1.getKartenfarbe(), Kartenfarbe.MENSCH);
-		assertEquals(n2.getFarbe(), Kartenfarbe.ELF);
+		assertEquals(n2.getKartenfarbe(), Kartenfarbe.ELF);
-		assertEquals(n3.getFarbe(), Kartenfarbe.RIESE);
+		assertEquals(n3.getKartenfarbe(), Kartenfarbe.RIESE);
-		assertEquals(n4.getFarbe(), Kartenfarbe.ZWERG);
+		assertEquals(n4.getKartenfarbe(), Kartenfarbe.ZWERG);
 		
 		assertEquals(n1.getBezeichnung(), "Narr");
 		assertEquals(n2.getBezeichnung(), "Narr");

Test/Domain/Karten/ZahlenkarteTest.java

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

Test/Domain/SpielerTest.java

@@ -12,18 +12,25 @@ import Domain.Spieler;
 import Domain.Enums.Geschlecht;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
 
 public class SpielerTest {
 
     Spieler spieler = new Spieler(0, "Herbert", Geschlecht.M, 0);
     Spieler spieler2 = new Spieler(1, "Heinz", Geschlecht.M, 0);
     Spieler spieler3 = new Spieler(2, "Ulrike", Geschlecht.W, 0);
+    Spieler spieler4 = new Spieler(3, "HerrFrau", Geschlecht.D, 0);
+    Spieler spieler5 = new Spieler(4, "", Geschlecht.KI, 0);
+    Spieler spieler6 = new Spieler(5, "", Geschlecht.KI, 0);
 
     @Test
     public void idTest() {
         assertEquals(0, spieler.getId());
         assertEquals(1, spieler2.getId());
         assertEquals(2, spieler3.getId());
+        assertEquals(3, spieler4.getId());
+        assertEquals(4, spieler5.getId());
+        assertEquals(5, spieler6.getId());
     }
 
     @Test
@@ -42,6 +49,11 @@ public class SpielerTest {
         assertEquals("Herbert", spieler.getName());
         spieler.setName("Heinz");
         assertEquals("Heinz", spieler.getName());
+        assertEquals("", spieler5.getName()); //Kein Name notwendig, da KI.
 
     }
+    @Test
+    public void exceptionsTest() {
+    	assertThrows(RuntimeException.class, () -> new Spieler(6, "", Geschlecht.KI, 0));
+    }
 }

UI/SpielCLI.java

@@ -121,10 +121,13 @@ public class SpielCLI {
             }
 
             int _id = Integer.parseInt(sc.nextLine());
-            System.out.println(_id);
+            // 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;