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

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

.gitignore

@@ -3,3 +3,12 @@
 
 # Object Data
 *.o
+
+# iml
+*.iml
+
+# Jar dateien
+/lib
+.idea
+/Main.class
+/RendomTest.class

.vscode/settings.json

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

Domain/Block.java

@@ -1,11 +0,0 @@
-/*
-============================================================
-This is the "Block" file from Author: Philipp Kotte
-written on: 05 / 10 / 2023 at: 23:43 
-============================================================
-*/
-package Domain;
-
-public class Block {
-
-}

Domain/Block/Block.java

@@ -0,0 +1,29 @@
+/*
+============================================================
+This is the "Block" file from Author: Philipp Kotte
+written on: 05 / 10 / 2023 at: 23:43 
+============================================================
+*/
+package Domain.Block;
+
+import java.util.ArrayList;
+
+public class Block {
+    private ArrayList<Blockzeile> zeilen;
+
+    public Block(){
+        this.zeilen = new ArrayList<>();
+    }
+
+    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]);
+    }
+}

Domain/Block/Blockeintrag.java

@@ -0,0 +1,76 @@
+/*
+============================================================
+This is the "Blockeintrag" file from Author: Philipp Kotte
+written on: 05 / 10 / 2023 at: 23:44 
+============================================================
+*/
+package Domain.Block;
+
+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, 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() {
+        return this.punkte;
+    }
+
+    public int getStiche() {
+        return this.stiche;
+    }
+
+    public void setStiche(int stiche) {
+        if (stiche < 0){
+            throw new IllegalArgumentException("Ihre Stich dürfen nicht im Negative bereich sein");
+        }
+        this.stiche = stiche;
+    }
+
+    public void setPunkte(int punkte) {
+        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

@@ -0,0 +1,86 @@
+/*
+============================================================
+This is the "Blockzeile" file from Author: Philipp Kotte
+written on: 05 / 10 / 2023 at: 23:44 
+============================================================
+*/
+package Domain.Block;
+
+import java.util.ArrayList;
+
+public class Blockzeile {
+
+    /*------------------------------------------*/
+    // statische Konstanten
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // statische Attribute(zB. zähler)
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // Attribute jedes Objektes
+    /*------------------------------------------*/
+
+    private int rundenNummer;
+    private ArrayList<Blockeintrag> eintraege;
+
+    /*------------------------------------------*/
+    // Konstruktoren (default und spezifische)
+    /*------------------------------------------*/
+
+    public Blockzeile(){
+
+    }
+
+    public Blockzeile(int rundenNummer, Blockeintrag eintrag) {
+        this.rundenNummer = rundenNummer;
+        this.eintraege = new ArrayList<>();
+        addEintrag(eintrag);
+    }
+    /*------------------------------------------*/
+    // statische Methoden
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // Getter und Setter
+    /*------------------------------------------*/
+    public int getRundenNummer() {
+        return rundenNummer;
+    }
+
+    public void setRundenNummer(int rundenNummer) {
+        this.rundenNummer = rundenNummer;
+    }
+    /*------------------------------------------*/
+    // @Overrides
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // öffentliche Methodes
+    /*------------------------------------------*/
+
+    public void addEintrag(Blockeintrag eintrag) {
+        if(eintraege != null){
+            eintraege.add(eintrag);
+        }
+    }
+
+    public Blockeintrag[] getDaten() {
+        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/Blockeintrag.java

@@ -1,12 +0,0 @@
-/*
-============================================================
-This is the "Blockeintrag" file from Author: Philipp Kotte
-written on: 05 / 10 / 2023 at: 23:44 
-============================================================
-*/
-package Domain;
-
-public class Blockeintrag {
-    public int punkte;
-    public int stiche;
-}

Domain/Blockzeile.java

@@ -1,25 +0,0 @@
-/*
-============================================================
-This is the "Blockzeile" file from Author: Philipp Kotte
-written on: 05 / 10 / 2023 at: 23:44 
-============================================================
-*/
-package Domain;
-
-public class Blockzeile {
-    public int rundenNummer;
-
-    public Blockzeile(int rundenNummer) {
-        this.rundenNummer = rundenNummer;
-    }
-
-    public void addEintrag(Blockeintrag be) {
-        // TODO: Implementation
-    };
-
-    public Blockeintrag[] getDaten() {
-        // TODO: Implementation
-        return new Blockeintrag[0];
-    }
-
-}

Domain/Enums/Geschlecht.java

@@ -7,6 +7,6 @@ written on: 05 / 10 / 2023 at: 23:31
 package Domain.Enums;
 
 public enum Geschlecht {
-	KI, M, W, D;
 
+	M, W, D, KI;
 }

Domain/Enums/Kartenfarbe.java

@@ -8,15 +8,21 @@ package Domain.Enums;
 
 public enum Kartenfarbe {
 
-	MENSCH("BLAU"), ELF("GRÜN"), ZWERG("ROT"), RIESE("GELG");
+	MENSCH("BLAU"), ZWERG("ROT"), ELF("GRÜN"), RIESE("GELB");
 
 	private String farbe;
 
-	Kartenfarbe(String farbe) {
+	private Kartenfarbe(String farbe) {
 		this.farbe = farbe;
 	}
 
 	public String getFarbe() {
-		return this.farbe;
+		return farbe;
 	}
+
+	@Override
+	public String toString() {
+		return getFarbe();
+	}
+
 }

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

@@ -1,65 +0,0 @@
-package Domain;
-
-import Domain.Karten.Karte;
-
-public class Hand {
-
-	// Statische Konstanten
-	
-	// Statische Attribute
-	
-	// Attribute der Objekte
-	private Karte[] aktuelleHand;
-	// Konstruktoren
-	public Hand(int runde) {
-		setAktuelleHand(runde);
-	}
-	// Statische Methoden
-	
-	// Getter und Setter
-	public Karte[] getAktuelleHand() {
-		return this.aktuelleHand;
-	}
-	private void setAktuelleHand(int runde) {
-		this.aktuelleHand = new Karte[runde];
-	}
-	
-	// Overrides
-	@Override
-	public String toString() {
-		return "";
-	}
-	// Public Methoden
-	/**
-	 * Zeigt die aktuelle Hand des Spielers an
-	 * @return
-	 */
-	public Karte[] zeigeHand() {
-		return this.aktuelleHand;
-	}
-	/**
-	 * Zeigt die höchste Karte auf der Hand des Spielers an
-	 * @return
-	 */
-	public Karte höchsteKarte() {
-		return null;
-	}
-	/**
-	 * Zeigt die niedrigste Karte auf der Hand des Spielers an
-	 * @return
-	 */
-	public Karte niedrigsteKarte() {
-		return null;
-	}
-	/**
-	 * Ermöglicht die Auswahl einer Karte, die der Spieler
-	 * ausspielen möchte
-	 * @return
-	 */
-	public Karte karteAuswählen() {
-		
-		return null;
-	}
-	// Private Methoden
-	
-}

Domain/Karten/Karte.java

@@ -11,40 +11,29 @@ public abstract class Karte {
 	// Statische Konstanten
 
 	// Statische Attribute
-	private static int kartenId = 0;
-	
-	// Attribute der Objekte (Kann es keine geben, da die Klasse abstrakt ist)
+	private int id;
+	// Attribute des Ojektes
 
 	// Konstruktoren
 	public Karte() {
-		if (kartenId <= 60) {
-			setKartenId();
-		}
-		else {
-			throw new RuntimeException("Es darf nur 60 Karten im Spiel geben.");
-		}
+
 	}
+
+	public Karte(int id) {
+		this.id = id;
+	}
+
 	// Statische Methoden
-	public static int getKartenId() {
-		return kartenId;
+
+	// Getter und Setter
+
+	public int getId() {
+		return this.id;
 	}
 
-	public static void setKartenId() {
-		kartenId++;
-	}
-	
-	// Getter und Setter (Kann es auch keine geben)
-	
-	// Overrides
-	@Override
-	public abstract String toString();
-	
-	// Public Methoden
-	
-	// Private Methoden
-	
-	
-
+	// @Overrides
 
+	// Public Methoden (öffentliche Methoden)
 
+	// Private Methoden (Hilfsmethoden)
 }

Domain/Karten/Magierkarte.java

@@ -6,57 +6,50 @@ 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
-	private static int mkAnzahl = 1; // mk = magierkarte
 
-	// Attribute der Objekte
+	// Attribute des Objekts
+	
 	private String name;
 	
 	// Konstruktoren
-	public Magierkarte() {
-		super();
-		if (getMkAnzahl() <= 4) {
-			setName(TRUMPF_NAME);
-			setMkAnzahl();
-		}
-		else {
-			throw new RuntimeException("Es darf nur 4 Zaubererkarten im Spiel geben.");
-		}
+
+	public Magierkarte(int id) {
+		super(id);
+		setName();
 
 	}
 
-	// Statischen Methoden
+	// Statische Methoden
 
 	// Getter und Setter
 
-	public int getMkAnzahl() {
-		return mkAnzahl;
+	public int getId() {
+		return super.getId();
 	}
 
-	public void setMkAnzahl() {
-		mkAnzahl++;
+	private void setName() {
+		this.name = NAME;
 	}
 
 	public String getName() {
-		return name;
-	}
-
-	public void setName(String name) {
-		this.name = name;
-	}
-	
-	// Overrides
-	@Override
-	public String toString() {
 		return this.name;
 	}
 
-	// public Methoden
 
-	// private Methoden
+	// @Overrides
+	@Override
+	public String toString() {
+		return "ID " + this.getId() +  ": " + this.getName();
+	}
+	// Public Methoden
+
+	// Private Methoden
+
 }

Domain/Karten/Narrenkarte.java

@@ -6,45 +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 final static String KARTE_NAME = "Narr";
+	private final static String NAME = "Narr";
 	// Statische Attribute
-	private static int nkAnzahl = 1;
-	// Attribute der Objekte
+
+	// Attribute des Objekts
+	
 	private String name;
 	// Konstruktoren
-	public Narrenkarte() {
-		super();
-		if (getNkAnzahl() <= 4) {
-			setName(KARTE_NAME);
-			setNkAnzahl();
-		}
-		else {
-			throw new RuntimeException("Es darf nur 4 Narrenkarten im Spiel geben.");
-		}
+
+	public Narrenkarte(int id) {
+		super(id);
+		setName();
+
 	}
 	// Statische Methoden
 
 	// Getter und Setter
-	private void setName(String name) {
-		this.name = name;
+	
+	public int getId() {
+		return super.getId();
 	}
+
+	private void setName() {
+		this.name = NAME;
+	}
+
 	public String getName() {
 		return this.name;
 	}
 
-	private void setNkAnzahl() {
-		nkAnzahl++;
+	public void setNarrenkarteanzahl(int narrenkarteanzahl) {
+		narrenkarteanzahl++;
 	}
-	public int getNkAnzahl() {
-		return nkAnzahl;
-	}
-	// Overrides
+
+	// @Overrides
 	@Override
 	public String toString() {
-		return this.name;
+		return "ID " + this.getId() + ": " + this.getName();
 	}
 	// Public Methoden
 

Domain/Karten/Zahlenkarte.java

@@ -10,93 +10,71 @@ import Domain.Enums.Kartenfarbe;
 
 public class Zahlenkarte extends Karte {
 
-	// Statische Konstanten
-	private final static String NAME = "Charakterkarte";
-	// Statische Attribute
-	private static int menschID = 1;
-	private static int elfID = 1;
-	private static int rieseID = 1;
-	private static int zwergID = 1;
-	// Attribute der Objekte
-	private int kartenwert;
-	private Kartenfarbe charakter;
-	private String name;
-	// Konstruktoren
+	/*------------------------------------------*/
+	// statische Konstanten
+	/*------------------------------------------*/
 
-	public Zahlenkarte(Kartenfarbe farbe) {
-		super();
-		if (farbe == Kartenfarbe.MENSCH && menschID <=13) {
-			setNeueMenschKarte(farbe);
-		}
-		else if (farbe == Kartenfarbe.ELF && elfID <= 13) {
-			setNeueElfKarte(farbe);
-		}
-		else if (farbe == Kartenfarbe.RIESE && rieseID <= 13) {
-			setNeueRieseKarte(farbe);
-		}
-		else if (farbe == Kartenfarbe.ZWERG && zwergID <= 13) {
-			setNeueZwergKarte(farbe);
-		}
-		else {
-			throw new RuntimeException("Es darf von jedem Charakter nur 13 Karten im Spiel geben.");
-		}
+	/*------------------------------------------*/
+	// statische Attribute(zB. zähler)
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
+	// Attribute jedes Objektes
+	/*------------------------------------------*/
+	private Kartenfarbe farbe;
+	private int kartenNummer;
+
+	/*------------------------------------------*/
+	// Konstruktoren (default und spezifische)
+	/*------------------------------------------*/
+	public Zahlenkarte(int id) {
+		super(id);
 	}
-	// Statische Methoden
 
+	public Zahlenkarte(int id, Kartenfarbe farbe, int kartenNummer) {
+		super(id);
+		setFarbe(farbe);
+		setKartenNummer(kartenNummer);
+
+	}
+	/*------------------------------------------*/
+	// statische Methoden
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
 	// Getter und Setter
-	public int getKartenwert() {
-		return kartenwert;
+	/*------------------------------------------*/
+	
+	public int getId() {
+		return super.getId();
 	}
 	
-	public void setKartenwert(int kartenwert) {
-		this.kartenwert = kartenwert;
+	public void setFarbe(Kartenfarbe farbe) {
+		this.farbe = farbe;
 	}
 
-	public Kartenfarbe getCharakter() {
-		return charakter;
+	public Kartenfarbe getFarbe() {
+		return farbe;
 	}
 
-	public void setCharakter(Kartenfarbe charakter) {
-		this.charakter = charakter;
+	public void setKartenNummer(int kartenNummer) {
+		this.kartenNummer = kartenNummer;
 	}
 
-	public void setName() {
-		this.name = NAME;
-	}
-	// Overrides
-	@Override
-	public String toString() {
-		return this.name + " " + this.charakter + " " + this.kartenwert;
-	}
-	// Public Methoden
-	
-	// Private Methoden
-	private void setNeueMenschKarte(Kartenfarbe farbe) {
-		setCharakter(farbe);
-		setKartenwert(menschID);
-		setName();
-		menschID++;
+	public int getKartenNummer() {
+		return kartenNummer;
 	}
 
-	private void setNeueElfKarte(Kartenfarbe farbe) {
-		setCharakter(farbe);
-		setKartenwert(elfID);
-		setName();
-		elfID++;
-	}
+	/*------------------------------------------*/
+	// @Overrides
+	/*------------------------------------------*/
 
-	private void setNeueRieseKarte(Kartenfarbe farbe) {
-		setCharakter(farbe);
-		setKartenwert(rieseID);
-		setName();
-		rieseID++;
-	}
+	/*------------------------------------------*/
+	// öffentliche Methodes
+	/*------------------------------------------*/
 
-	private void setNeueZwergKarte(Kartenfarbe farbe) {
-		setCharakter(farbe);
-		setKartenwert(zwergID);
-		setName();
-		zwergID++;
-	}
+	/*------------------------------------------*/
+	// Hilfsmethoden (privat)
+	/*------------------------------------------*/
 
 }

Domain/Kartenstapel.java

@@ -8,16 +8,12 @@ package Domain;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
-
+import java.util.HashMap;
 import Domain.Enums.Kartenfarbe;
-import Domain.Karten.Karte;
-import Domain.Karten.Magierkarte;
-import Domain.Karten.Narrenkarte;
-import Domain.Karten.Zahlenkarte;
-import Facade.Spiel;
+import Domain.Karten.*;
+
 
 public class Kartenstapel {
 
@@ -37,33 +33,33 @@ public class Kartenstapel {
 
 	// Konstruktoren
 	public Kartenstapel() {
-		if (Karte.getKartenId() != 60) {
-			// Erstelle Magierkarten
-			for (int i = 1; i <= 4; i++) {
-				kartensortiert.put(i, new Magierkarte());
-			}
-			// Erstelle Narrenkarten
-			for (int i = 5; i <= 8; i++) {
-				kartensortiert.put(i, new Narrenkarte());
-			}
-			// Erstelle Charakterkarten MENSCH
-			for (int i = 9; i <= 21; i++) {
-				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.MENSCH));
-			}
-			// Erstelle Charakterkarten ELF
-			for (int i = 22; i <= 34; i++) {
-				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.ELF));
-			}
-			// Erstelle Charakterkarten RIESE
-			for (int i = 35; i <= 47; i++) {
-				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.RIESE));
-			}
-			// Erstelle Charakterkarten ZWERG
-			for (int i = 48; i <= 60; i++) {
-				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.ZWERG));
-			}
-
+		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
 
@@ -124,6 +120,10 @@ public class Kartenstapel {
 			kartengemischt.put(i + 1, kartensortiert.get(schlüsselzahl));
 			zahlen.remove(index);
 		}
+		
+		for(Karte k : kartengemischt.values()) {
+			System.out.println(k.toString());
+		}
 	}
 
 	/**
@@ -132,26 +132,13 @@ public class Kartenstapel {
 	 * falls noch eine Karte auf dem Stapel liegen sollte. Hierzu wird die Runde,
 	 * als Ausgangswert genommen.
 	 */
-	public Karte getObersteKarte() {
-		// Todo: Nur für den Trumpf
-		Karte austeilen = null;
-		if (kartengemischt.get(kartenzählen) != null && kartenzählen <= 60) {
-			
-			austeilen = kartengemischt.get(kartenzählen);
-			kartengemischt.remove(kartenzählen);
-			kartenzählen++;
-			
-		} 
-		else if (kartenzählen > 60) {
-			throw new RuntimeException("Es können nicht mehr als 60 Karten ausgeteilt werden.");
-		}
-		else {
-			throw new RuntimeException("Es ist ein Fehler in 'Kartenzählen' aufgetaucht.");
-		}
-
-		return austeilen;
+	public Object getObersteKarte() {
+		Object k = kartengemischt.values().toArray()[0];
+		kartengemischt.remove(k);
+		return k;
 	}
 	
+	
 	/**
 	 * 
 	 */

Domain/Spieler.java

@@ -6,114 +6,185 @@ written on: 05 / 10 / 2023 at: 23:48
 */
 package Domain;
 
-import java.io.Serializable;
-
 import Domain.Enums.Geschlecht;
 
-public class Spieler implements Serializable{
+import java.io.Serializable;
 
-	// Statische Konstanten
-	private final static String BOTNAME = "Spieler (KI): "; // KI erhält einen konstanten Namen + id(zähler)
-	// Statische Attribute
-	private static int id = 1; // Interner Zähler für Prüfung max Spieler und für Name KI(BOTNAME + id)
-	// Attribute der Objekte
-	private int spielerID; // Feste SpielerID zur Festlegung der Ref-Variablen
-	private String name; // Name eines Spielers oder fester Name falls Geschlecht.KI
-	private Geschlecht geschlecht; 
-	private Hand hand;
+public class Spieler extends Object implements Serializable {
+
+	/*------------------------------------------*/
+	// statische Konstanten
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
+	// statische Attribute(zB. zähler)
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
+	// Attribute jedes Objektes
+	/*------------------------------------------*/
+	private int id = 0;
+	private String name;
 	private int vorhersage;
-	// Konstruktoren
+	private Geschlecht geschlecht;
+	//
+
+	/*------------------------------------------*/
+	// Konstruktoren (default und spezifische)
+	/*------------------------------------------*/
+	// Default
 	/**
-	 * Die Prüfung, ob der @param name leer ist, muss in der Klasse Spiel erfolgen.
-	 * Es wird der @param id noch zusätzlich geprüft.
-	 * @param geschlecht wird übergeben, als MinAnforderung
+	 * Default Konstruktor des Spieler - Klasse
 	 */
-	public Spieler(Geschlecht geschlecht) { 
-		if (id <= 6) {
-			if (geschlecht != Geschlecht.KI) {
-				setGeschlecht(geschlecht);
-				setVorhersage(0);
-				setHand(0);
-				setSpielerID(id);
-			}
-			else {
-				setNeuerBot(geschlecht);
-			}
-		}
-		else {
-			throw new RuntimeException("Es kann nur max 6 Spieler pro Spiel geben.");
-		}
+	public Spieler() {
 
 	}
-	/**
-	 * Der Konstruktor prüft die Länge des @param name ob mehr als zwei
-	 * Zeichen übergeben wurden. Geschlecht wird mit @code this(geschlecht) an 
-	 * den oberen Konstruktor übergeben.
-	 * @param geschlecht
-	 * @param name
-	 */
-	public Spieler(Geschlecht geschlecht, String name) {
-		this(geschlecht); // Frage: Wird hier (auch wenn Folgebedingung nicht erfüllt) ein Bot angelegt?
-		if (name.length() < 3) {
-			throw new RuntimeException("Der Spielername muss min. 3 Zeichen lang sein.");
-		}
-		else {
-			setName(name);
-		}
-	}
-	// Statische Methoden
 
+	/**
+	 * Konstruktor des Spieler - Klasse mit den Werten id, name und geschlecht
+	 * 
+	 * @param id         int
+	 * @param name       String
+	 * @param geschlecht Geschlecht
+	 */
+	public Spieler(int id, String name, Geschlecht geschlecht) {
+		this();
+		if (id < 6) {
+			setId(id);
+		} 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);
+	}
+
+	/**
+	 * Konstruktor des Spieler - Klasse mit den Werten id, name, geschlecht und
+	 * Vorhersage
+	 * 
+	 * @param id         int
+	 * @param name       String
+	 * @param geschlecht Geschlecht
+	 * @param vorhersage int
+	 */
+	public Spieler(int id, String name, Geschlecht geschlecht, int vorhersage) {
+		this(id, name, geschlecht);
+		setVorhersage(vorhersage);
+	}
+
+	/*------------------------------------------*/
+	// statische Methoden
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
 	// Getter und Setter
-	public void setGeschlecht(Geschlecht geschlecht) {
-		this.geschlecht = geschlecht;
-	}
-	public Geschlecht getGeschlecht() {
-		return this.geschlecht;
+	/*------------------------------------------*/
+	// id
+	/**
+	 * Setzt die ID des Spielers
+	 * 
+	 * @param int id
+	 */
+	private void setId(int id) {
+		this.id = id;
 	}
 
+	/**
+	 * Gibt die ID des Spielers zurück
+	 * 
+	 * @return int id
+	 */
+	public int getId() {
+		return id;
+	}
+
+	// name
+	/**
+	 * Setzt den Namen des Spielers
+	 * 
+	 * @param String name
+	 */
 	public void setName(String name) {
 		this.name = name;
 	}
+
+	/**
+	 * Gibt den Namen des Spielers zurück
+	 * 
+	 * @return String name
+	 */
 	public String getName() {
 		return this.name;
 	}
 
+	// geschlecht
+	/**
+	 * Setzt das Geschlecht des Spielers wie definiert in
+	 * {@link Domain.Enums.Geschlecht}
+	 * 
+	 * @param geschlecht
+	 */
+	public void setGeschlecht(Geschlecht geschlecht) {
+		this.geschlecht = geschlecht;
+	}
+
+	/**
+	 * Gibt das Geschlecht des Spielers zurück wie definiert in
+	 * {@link Domain.Enums.Geschlecht}
+	 * 
+	 * @return
+	 */
+	public Geschlecht getGeschlecht() {
+		return geschlecht;
+	}
+
+	// vorhersage
+	/**
+	 * Setzt die Vorhersage des Spielers
+	 * 
+	 * @param int vorhersage
+	 */
 	public void setVorhersage(int vorhersage) {
 		this.vorhersage = vorhersage;
 	}
+
+	/**
+	 * Gibt die Vorhersage von dem Spieler zurück
+	 * 
+	 * @return int vorhersage
+	 */
 	public int getVorhersage() {
-		return this.vorhersage;
+		return vorhersage;
 	}
 
-	public void setSpielerID(int id) {
-		this.spielerID = id;
-		setId();
-	}
-	public int getSpielerID() {
-		return this.spielerID;
-	}
-	public void setHand(int runde) {
-		this.hand = new Hand(runde);
-	}
-	public Hand getHand() {
-		return this.hand;
-	}
-	// Overrides
+	/*------------------------------------------*/
+	// @Overrides
+	/*------------------------------------------*/
 
-	// Public Methoden
-	
-	// Private Methoden
-	private void setNeuerBot(Geschlecht geschlecht) {
-		this.spielerID = id;
-		this.name = BOTNAME + " " + id;
-		this.geschlecht = geschlecht;
-		setVorhersage(0); 	// Nicht zwingend notwendig, aber dient
-		setHand(0);			// der Übersicht aller Attribute.
-		setId();
+	/**
+	 * Überschreibt die toString methode für eine eigene Implementation um den
+	 * Spieler als String zurück zu geben
+	 * 
+	 * @return ID: "id" Name: "name" ("geschlecht")
+	 * 
+	 */
+	@Override
+	public String toString() {
+		return "ID: " + this.id + " Name: " + this.name + " (" + this.geschlecht + ")";
 	}
 
-	private void setId() {
-			id++;
+	/*------------------------------------------*/
+	// öffentliche Methodes
+	/*------------------------------------------*/
+
+	/*------------------------------------------*/
+	// Hilfsmethoden (privat)
+	/*------------------------------------------*/
 
-	}
 }

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

@@ -6,53 +6,259 @@ written on: 05 / 10 / 2023 at: 23:25
 */
 package Facade;
 
+import java.io.Serializable;
+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 {
+public class Spiel implements Serializable {
 
-	// Statische Konstanten
+    /*--------------------------------------------------------*/
+    // statische Konstanten
+    /*--------------------------------------------------------*/
 
-	// Statische Attribute
-	private static int runde = 0;
+    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";
 
-	// Attribute der Objekte
-	private Spieler spielerAmZug;
-	private boolean istGestartet = false;
-	private boolean istBeendet = true;
-	// Konstruktoren
-	public Spiel() {
-		setRunde();
-		setIstGestartet(true);
-		setIstBeendet(false);
-	}
-	// Statische Methoden
-	public static int getRunde() {
-		return runde;
-	}
-	// Getter und Setter
-	public void setIstGestartet(boolean wert) {
-		this.istGestartet = wert;
-	}
-	public boolean getIstGestartet() {
-		return this.istGestartet;
-	}
-	public void setIstBeendet(boolean wert) {
-		this.istBeendet = wert;
-	}
-	public boolean getIstBeendet() {
-		return istBeendet;
-	}
-	public Spieler getSpielerAmZug() {
-		return spielerAmZug;
-	}
-	// Overrides
+    /*--------------------------------------------------------*/
+    // statische Attribute(zB. zähler)
+    /*--------------------------------------------------------*/
 
-	// Public Methoden
+    /*--------------------------------------------------------*/
+    // Attribute jedes Objektes
+    /*--------------------------------------------------------*/
 
-	// Private Methoden
-	private void setRunde() {
-		runde++;
-	}
+    private boolean istGestartet;
+    private boolean istBeendet;
+    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;
 
+    /*--------------------------------------------------------*/
+    // Konstruktoren (default und spezifische)
+    /*--------------------------------------------------------*/
+
+    public Spiel() {
+        this.istGestartet = false;
+        this.istBeendet = false;
+        this.spielerAmZug = null;
+        this.runde = 0;
+        this.kartenstapel = new Kartenstapel();
+    };
+    /*--------------------------------------------------------*/
+    // statische Methoden
+    /*--------------------------------------------------------*/
+
+    /*--------------------------------------------------------*/
+    // Getter und Setter
+    /*--------------------------------------------------------*/
+
+    public void setSpielGestartet(boolean gestarted) {
+        this.istGestartet = gestarted;
+    }
+
+    public void setSpielBeendet(boolean beendet) {
+        this.istBeendet = beendet;
+    }
+
+    public void setRunde(int runde) {
+        this.runde = runde;
+    }
+
+    public void setSpielerAmZug(Spieler spieler) {
+        this.spielerAmZug = spieler;
+    }
+
+    /*--------------------------------------------------------*/
+    // @Overrides
+    /*--------------------------------------------------------*/
+
+    @Override
+    public String toString() {
+        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;
+    }
+
+    /*--------------------------------------------------------*/
+    // öffentliche Methodes
+    /*--------------------------------------------------------*/
+
+    public void addSpieler(String name, Geschlecht geschlecht) {
+        int id = 1;
+        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 {
+        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()];
+        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;
+            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() {
+        return new String[1];
+    }
+
+    public boolean istSpielGestartet() {
+        return this.istGestartet;
+    }
+
+    public boolean istSpielBeendet() {
+        return this.istBeendet;
+    }
+
+    public String[][] getBlock() {
+        return new String[0][0];
+    }
+
+    public String getGewinner() {
+        return "";
+    }
+
+    public int getRunde() {
+        return this.runde;
+    }
+
+    public void mischen() {
+
+    }
+
+    public void austeilen() {
+
+        // Spieler 1 bekommt karten
+
+        // Spieler 2 bekommt Karten
+        // ...
+
+        // letzer Spieler bekommt Karten
+
+    }
+
+    public void ausspielen(int idKarte) {
+
+    }
+
+    public void vorhersagen(int stiche) {
+
+    }
+
+    /*--------------------------------------------------------*/
+    // 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;
+        }
+    }
 
 }

Infrastructure/Persistenz.java

@@ -6,7 +6,69 @@ written on: 05 / 10 / 2023 at: 23:25
 */
 package Infrastructure;
 
+import Facade.Spiel;
+
+import java.io.*;
+
 public class Persistenz {
 
+    /*------------------------------------------*/
+    // statische Konstanten
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // statische Attribute(zB. zähler)
+    /*------------------------------------------*/
+
+    final static String FILE_NAME = "WIZARD_DATA_";
+
+    /*------------------------------------------*/
+    // Attribute jedes Objektes
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // Konstruktoren (default und spezifische)
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // statische Methoden
+    /*------------------------------------------*/
+
+    public static boolean sindDatenVorhanden(String name) {
+        File f = new File(FILE_NAME + name + ".ser");
+        if (f.exists()) {
+            return true;
+        }
+        return false;
+    }
+
+    public static void speichereDaten(String name, Spiel spiel) throws IOException {
+        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME + name + ".ser"));
+        oos.writeObject(spiel);
+        oos.close();
+    }
+
+    public static Object ladeDaten(String name) throws IOException, ClassNotFoundException {
+        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME + name + ".ser"));
+        Object spiel = ois.readObject();
+        ois.close();
+        return spiel;
+    }
+
+    /*------------------------------------------*/
+    // Getter und Setter
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // @Overrides
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // öffentliche Methodes
+    /*------------------------------------------*/
+
+    /*------------------------------------------*/
+    // Hilfsmethoden (privat)
+    /*------------------------------------------*/
 
 }

Main.java

@@ -0,0 +1,43 @@
+import Facade.Spiel;
+import Infrastructure.Persistenz;
+import UI.SpielCLI;
+
+import java.io.IOException;
+
+public class Main {
+    public static void main(String[] args) {
+        String name = "Wizard";
+        Spiel spiel = null;
+
+        if (Persistenz.sindDatenVorhanden(name)) {
+            try {
+                System.out.println("Lade daten");
+                spiel = (Spiel) Persistenz.ladeDaten(name);
+                System.out.println("laden erfolgreich");
+            } catch (IOException e) {
+                System.out.println("Konnte file nicht laden.");
+                System.out.println(e.getLocalizedMessage());
+
+            } catch (ClassNotFoundException cnfe) {
+                System.out.println("Konnte file nicht laden.");
+                System.out.println(cnfe.getLocalizedMessage());
+            } finally {
+                if (spiel == null) {
+                    System.out.println("Initialisiere neues Spiel");
+                    spiel = new Spiel();
+                }
+            }
+
+        } else {
+            spiel = new Spiel();
+        }
+
+        new SpielCLI(spiel);
+
+        try {
+            Persistenz.speichereDaten(name, spiel);
+        } catch (IOException e) {
+            System.out.println("Konnte Daten nicht speicher!");
+        }
+    }
+}

README.md

@@ -9,6 +9,60 @@ Gruppe Studienleistung bereits vorhanden
 - Mohammad Hawrami
 - Philipp Kotte
 
+## Dopatka Regeln wie Klassen anzulegen sind
+
+### Aufbau
+
+1. statische Konstante
+2. statische Attribute(zB. zähler)
+3. Attribute jedes Objektes
+4. Konstruktoren (default und spezifische)
+5. statische Methoden
+6. Getter und Setter
+7. @Overrides
+8. öffentliche Methodes
+9. Hilfsmethoden (privat)
+
+### Template
+
+```
+/*------------------------------------------*/
+// statische Konstanten
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// statische Attribute(zB. zähler)
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// Attribute jedes Objektes
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// Konstruktoren (default und spezifische)
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// statische Methoden
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// Getter und Setter
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// @Overrides
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// öffentliche Methodes
+/*------------------------------------------*/
+
+/*------------------------------------------*/
+// Hilfsmethoden (privat)
+/*------------------------------------------*/
+```
+
 ## Für das Arbeiten mit geschützten Mainbranch
 
 Wenn Änderungen durchgeführt werden müssen, kann dieses nicht direkt auf dem main-Branch gepusht werden sondern muss mit einem Separatem Branch und Pull-Request durchgeführt werden.
@@ -34,3 +88,29 @@ Besonders wenn eine Weile an dem Feature Branch gearbeitet wurde, können bereit
 
 Danach damit wir alle die Changes mitbekommen muss ein Pull Request auf Gitea gestellt werden.
 Im zuge dessen findet eine Code Review von einem beliebigen Teammitglied statt, damit dieser frei gegeben werden kann.
+
+## Anmerkungen von Dopatka im Forum
+
+### Kartenstapel
+
+1. [ ] Die Methode getObsersteKarte soll nur den wert zurückgeben, diese aber nicht ziehen
+2. [ ] Die Methode mischen() kann gelöscht werden da die Spieler keine möglichkeit haben sollen dies selbst anzustoßen. Vorschlag -> wir behalten sie als private und rufen sie an der benötigten Stele auf
+
+### Karten
+
+1. [ ] Magierkarte wurde zu Zaubererkarte umbenannt
+
+### Spieler
+
+1. [ ] Speicherung der Karten des Spieler in der Klasse Spieler
+2. [ ] Die Namen der Spieler müssen mindestens 3 und dürfen maximal 9 Zeichen lang sein a-z A-Z 0-9 -\_
+
+### Spiel
+
+1. [ ] Die Methode getSpielerAmZug(): String[] soll einen Spieler mit all seinen Daten representieren und alle Daten des Spielers zurückgeben
+
+2. [ ] Es dürfen während des Spiels keine Spieler gelsöscht oder hinzugfügt werden
+
+### Allgemein
+
+1. [ ] toString methode für jede Klasse

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

@@ -0,0 +1,101 @@
+/*
+============================================================
+This is the "BlockTest" file from Author: Philipp Kotte
+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

@@ -0,0 +1,44 @@
+/*
+============================================================
+This is the "BlockeintragTest" file from Author: Philipp Kotte
+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

@@ -0,0 +1,107 @@
+/*
+============================================================
+This is the "BlockzeileTest" file from Author: Philipp Kotte
+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

@@ -0,0 +1,40 @@
+/*
+============================================================
+This is the "MagierkarteTest" file from Author: Philipp Kotte
+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.Magierkarte;
+
+
+public class MagierkarteTest {
+
+	
+	@Test
+	public void vierMagier() {
+		Magierkarte m1 = new Magierkarte(1);
+		Magierkarte m2 = new Magierkarte(2);
+		Magierkarte m3 = new Magierkarte(3);
+		Magierkarte m4 = new Magierkarte(4);
+
+		
+		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());
+
+	}
+
+}

Test/Domain/Karten/NarrenkarteTest.java

@@ -0,0 +1,39 @@
+/*
+============================================================
+This is the "NarrenkarteTest" file from Author: Philipp Kotte
+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 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());
+
+		
+	}
+}

Test/Domain/Karten/ZahlenkarteTest.java

@@ -0,0 +1,87 @@
+/*
+============================================================
+This is the "ZahlenkarteTest" file from Author: Philipp Kotte
+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
+	public void zahlenkartentesten() {
+		
+		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());
+		
+		
+		
+	}	
+		
+
+}

Test/Domain/KartenstapelTest.java

@@ -1,60 +1,28 @@
+/*
+============================================================
+This is the "KartenstapelTest" file from Author: Philipp Kotte
+written on: 10 / 10 / 2023 at: 20:41 
+============================================================
+*/
 package Test.Domain;
 
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.Test;
 
-import org.junit.jupiter.api.Test;
+public class KartenstapelTest {
 
-import Domain.Kartenstapel;
-import Domain.Enums.Kartenfarbe;
-import Domain.Karten.Karte;
-import Domain.Karten.Magierkarte;
-import Domain.Karten.Narrenkarte;
-import Domain.Karten.Zahlenkarte;
+    @Test
+    public void mischenTest() {
 
-class KartenstapelTest {
+    }
 
-	@Test
-	void testKartenstapelSortiert() {
-		Kartenstapel k = new Kartenstapel();
+    @Test
+    public void getAnzahlKartenTest() {
 
-		System.out.println(k.getKartenstapelSortiert());
-		k.mischen();
-		System.out.println(k.getKartenstapelGemischt());
-		System.out.println(k.getStatusGemischt());
-		// Test der richtigen Klassen
-		assertInstanceOf(Magierkarte.class, k.getKartesortiert(1));
-		assertInstanceOf(Magierkarte.class, k.getKartesortiert(4));
-		assertInstanceOf(Narrenkarte.class, k.getKartesortiert(5));
-		assertInstanceOf(Narrenkarte.class, k.getKartesortiert(8));
-		assertInstanceOf(Zahlenkarte.class, k.getKartesortiert(9));
-		assertInstanceOf(Zahlenkarte.class, k.getKartesortiert(17));
-		assertInstanceOf(Zahlenkarte.class, k.getKartesortiert(26));
-		assertInstanceOf(Zahlenkarte.class, k.getKartesortiert(45));
-		assertInstanceOf(Zahlenkarte.class, k.getKartesortiert(60));
+    }
 
-		// Test der richtigen Bezeichnungen für Magierkarten und Narrenkarten
-		assertTrue("Zauberer" == ((Magierkarte) k.getKartesortiert(2)).getName());
-		assertTrue("Narr" == ((Narrenkarte) k.getKartesortiert(5)).getName());
+    @Test
+    public void getObersteKarteTest() {
 
-		// Test der richtigen Werte auf den Zahlenkarten
-		// Charakterkarte MENSCH
-		assertTrue(1 == ((Zahlenkarte) k.getKartesortiert(9)).getKartenwert());
-		assertTrue(13 == ((Zahlenkarte) k.getKartesortiert(21)).getKartenwert());
-		assertEquals(Kartenfarbe.MENSCH.getFarbe(), ((Zahlenkarte) k.getKartesortiert(17)).getCharakter().getFarbe());
-		assertTrue(9 == ((Zahlenkarte) k.getKartesortiert(17)).getKartenwert());
-		
-		// Charakterkarte ELF
-		assertTrue(1 == ((Zahlenkarte) k.getKartesortiert(22)).getKartenwert());
-		assertTrue(13 == ((Zahlenkarte) k.getKartesortiert(34)).getKartenwert());
-		assertEquals(Kartenfarbe.ELF.getFarbe(), ((Zahlenkarte) k.getKartesortiert(25)).getCharakter().getFarbe());
-		assertTrue(4 == ((Zahlenkarte) k.getKartesortiert(25)).getKartenwert());
-		
-		// Charakterkarte RIESE
-		
-		
-		// Charakterkarte ZWERG
-		
-		
-	}
+    }
 
 }

Test/Domain/SpielerTest.java

@@ -0,0 +1,59 @@
+/*
+============================================================
+This is the "SpielerTest" file from Author: Philipp Kotte
+written on: 10 / 10 / 2023 at: 20:27 
+============================================================
+*/
+package Test.Domain;
+
+import org.junit.Test;
+
+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
+    public void geschlechtTest() {
+        assertEquals(Geschlecht.M, spieler.getGeschlecht());
+        spieler.setGeschlecht(Geschlecht.D);
+        assertEquals(Geschlecht.D, spieler.getGeschlecht());
+        spieler.setGeschlecht(Geschlecht.W);
+        assertEquals(Geschlecht.W, spieler.getGeschlecht());
+        spieler.setGeschlecht(Geschlecht.KI);
+        assertEquals(Geschlecht.KI, spieler.getGeschlecht());
+    }
+
+    @Test
+    public void nameTest() {
+        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));
+    }
+}

Test/Facade/SpielTest.java

@@ -0,0 +1,11 @@
+/*
+============================================================
+This is the "SpielTest" file from Author: Philipp Kotte
+written on: 10 / 10 / 2023 at: 21:19 
+============================================================
+*/
+package Test.Facade;
+
+public class SpielTest {
+
+}

Test/UI/PersistenzTest.java

@@ -0,0 +1,11 @@
+/*
+============================================================
+This is the "PersistenzTest" file from Author: Philipp Kotte
+written on: 10 / 10 / 2023 at: 21:21 
+============================================================
+*/
+package Test.UI;
+
+public class PersistenzTest {
+
+}

Test/UI/SpielCLITest.java

@@ -0,0 +1,11 @@
+/*
+============================================================
+This is the "SpielCLITest" file from Author: Philipp Kotte
+written on: 10 / 10 / 2023 at: 21:21 
+============================================================
+*/
+package Test.UI;
+
+public class SpielCLITest {
+
+}

UI/SpielCLI.java

@@ -7,6 +7,160 @@ written on: 05 / 10 / 2023 at: 23:25
 
 package UI;
 
-public abstract class SpielCLI {
-    public int id;
+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;
+
+    public SpielCLI(Spiel spiel) {
+        this.spiel = spiel;
+        hauptmenue();
+    }
+
+    public void hauptmenue() {
+        System.out.println("Hallo Wanderer");
+        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;
+
+            try {
+                input = Integer.parseInt(sc.nextLine());
+            } catch (NumberFormatException e) {
+                System.out.println("Diese eingabe ist ungültig.");
+            }
+
+            switch (input) {
+                case 1:
+                    spielStarten();
+                    break;
+                case 2:
+                    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.");
+            }
+        }
+        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);
+    }
+
 }

main/Main.java

@@ -1,15 +0,0 @@
-package main;
-
-import Facade.Spiel;
-import Infrastructure.Persistenz;
-
-public class Main {
-
-	public static void main(String[] args) {
-
-		String spielname = "Wizard";
-		Spiel spiel;
-
-	}
-
-}