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

@@ -2,4 +2,13 @@
 *.ser
 
 # Object Data
-*.o
+*.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

@@ -8,4 +8,5 @@ package Domain.Enums;
 
 public enum Geschlecht {
 
+	M, W, D, KI;
 }

Domain/Enums/Kartenfarbe.java

@@ -8,4 +8,21 @@ package Domain.Enums;
 
 public enum Kartenfarbe {
 
+	MENSCH("BLAU"), ZWERG("ROT"), ELF("GRÜN"), RIESE("GELB");
+
+	private String farbe;
+
+	private Kartenfarbe(String farbe) {
+		this.farbe = farbe;
+	}
+
+	public String getFarbe() {
+		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/Karten/Karte.java

@@ -6,6 +6,34 @@ written on: 05 / 10 / 2023 at: 23:28
 */
 package Domain.Karten;
 
-public class Karte {
+public abstract class Karte {
 
+	// Statische Konstanten
+
+	// Statische Attribute
+	private int id;
+	// Attribute des Ojektes
+
+	// Konstruktoren
+	public Karte() {
+
+	}
+
+	public Karte(int id) {
+		this.id = id;
+	}
+
+	// Statische Methoden
+
+	// Getter und Setter
+
+	public int getId() {
+		return this.id;
+	}
+
+	// @Overrides
+
+	// Public Methoden (öffentliche Methoden)
+
+	// Private Methoden (Hilfsmethoden)
 }

Domain/Karten/Magierkarte.java

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

Domain/Karten/Narrenkarte.java

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

Domain/Karten/Zahlenkarte.java

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

Domain/Kartenstapel.java

@@ -6,6 +6,142 @@ written on: 05 / 10 / 2023 at: 23:42
 */
 package Domain;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+import java.util.HashMap;
+import Domain.Enums.Kartenfarbe;
+import Domain.Karten.*;
+
+
 public class Kartenstapel {
 
+	// Statische Konstanten
+
+	// Statische Attribute
+	private static int kartenzählen = 1;
+	// Attribute der Objekte
+	
+	/**
+	 * Die HashMap besitzt alle Karten in sortierter Reihenfolge Die ArrayList wird
+	 * durch Zufall erzeugt und gibt den Key der HashMap wieder. D.h.
+	 */
+	private HashMap<Integer, Karte> kartensortiert = new HashMap<>();
+
+	private HashMap<Integer, Karte> kartengemischt = new HashMap<>();
+
+	// Konstruktoren
+	public Kartenstapel() {
+		kartensortiert.clear();
+		// Erstelle Magierkarten
+		for (int i = 1; i <= 4; i++) {
+			kartensortiert.put(i, new Magierkarte(i));
+		}
+		// Erstelle Narrenkarten
+		for (int i = 5; i <= 8; i++) {
+			kartensortiert.put(i, new Narrenkarte(i));
+		}
+		// Erstelle Charakterkarten MENSCH
+		for (int i = 9; i <= 21; i++) {
+			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8));
+		}
+		// Erstelle Charakterkarten ELF
+		for (int i = 22; i <= 34; i++) {
+			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ELF, i - 21));
+		}
+		// Erstelle Charakterkarten RIESE
+		for (int i = 35; i <= 47; i++) {
+			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.RIESE, i - 34));
+		}
+		// Erstelle Charakterkarten ZWERG
+		for (int i = 48; i <= 60; i++) {
+			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
+		}
+
+	
+	}
+	// Statische Methoden
+
+	// Getter und Setter
+	public Karte getKartesortiert(Integer index) {
+		return kartensortiert.get(index);
+	}
+	// Overrides
+
+	// Public Methoden
+	/**
+	 * Die Collection der HashMap 'kartensortiert'.
+	 * 
+	 * @return Die Kartenreferenzen der HashMap.
+	 */
+	public Collection<Karte> getKartenstapelSortiert() {
+		return kartensortiert.values();
+	}
+
+	public Collection<Karte> getKartenstapelGemischt() {
+		return kartengemischt.values();
+	}
+
+	/**
+	 * Methode für die Testklasse KartenstapelTest, um die Sortierung Visuell zu
+	 * bestätigen. Kann nach Finalem Test und Freigabe gelöscht oder auskommentiert
+	 * werden.
+	 * 
+	 * @return 'kg' Eine Namensliste des gemischten Kartenstapel
+	 */
+	public HashMap<Integer, String> getStatusGemischt() {
+		HashMap<Integer, String> kg = new HashMap<>();
+		for (int i = 1; i <= 60; i++) {
+			kg.put(i, ((String) kartengemischt.get(i).toString()));
+		}
+		return kg;
+	}
+
+	/**
+	 * Methode mischen(): beinhaltet eine ArrayList 'zahlen' die Zahlenwerte von 1
+	 * bis 60 zur Verfügung stellt.
+	 * 
+	 * @code Mit Random wird ein Zufallsindex gewählt. 'kartensortiert' und
+	 *       'kartengemsicht' sind zwei HashMap. 'kartensortiert' beinhaltet alle
+	 *       Karten in einer initialisierten Reihenfolge. 'kartengemischt' wird
+	 *       durch die @code Random 'zufall' befüllt.
+	 * 
+	 */
+	public void mischen() {
+		ArrayList<Integer> zahlen = new ArrayList<>();
+		for (int i = 1; i <= 60; i++) {
+			zahlen.add(i);
+		}
+		Random zufall = new Random();
+		for (int i = 0; i < 60; i++) {
+			int index = zufall.nextInt(zahlen.size());
+			int schlüsselzahl = zahlen.get(index);
+			kartengemischt.put(i + 1, kartensortiert.get(schlüsselzahl));
+			zahlen.remove(index);
+		}
+		
+		for(Karte k : kartengemischt.values()) {
+			System.out.println(k.toString());
+		}
+	}
+
+	/**
+	 * Methode getObersteKarte(): Hier wird der Reihe nach die jeweils oberste Karte
+	 * an den Spieler verteilt, bzw. am Ende des Verteilens der Trumpf gezogen,
+	 * falls noch eine Karte auf dem Stapel liegen sollte. Hierzu wird die Runde,
+	 * als Ausgangswert genommen.
+	 */
+	public Object getObersteKarte() {
+		Object k = kartengemischt.values().toArray()[0];
+		kartengemischt.remove(k);
+		return k;
+	}
+	
+	
+	/**
+	 * 
+	 */
+	// Private Methoden
+
 }

Domain/Spieler.java

@@ -6,6 +6,185 @@ written on: 05 / 10 / 2023 at: 23:48
 */
 package Domain;
 
-public class Spieler {
+import Domain.Enums.Geschlecht;
+
+import java.io.Serializable;
+
+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;
+	private Geschlecht geschlecht;
+	//
+
+	/*------------------------------------------*/
+	// Konstruktoren (default und spezifische)
+	/*------------------------------------------*/
+	// Default
+	/**
+	 * Default Konstruktor des Spieler - Klasse
+	 */
+	public Spieler() {
+
+	}
+
+	/**
+	 * 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
+	/*------------------------------------------*/
+	// 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 vorhersage;
+	}
+
+	/*------------------------------------------*/
+	// @Overrides
+	/*------------------------------------------*/
+
+	/**
+	 * Ü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 + ")";
+	}
+
+	/*------------------------------------------*/
+	// ö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,6 +6,259 @@ written on: 05 / 10 / 2023 at: 23:25
 */
 package Facade;
 
-public class Spiel {
+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 implements Serializable {
+
+    /*--------------------------------------------------------*/
+    // statische Konstanten
+    /*--------------------------------------------------------*/
+
+    private static final String ANSI_RESET = "\u001B[0m";
+    private static final String ANSI_GREEN = "\u001B[32m";
+    private static final String ANSI_RED = "\u001B[31m";
+    public static final String ANSI_BLUE = "\u001B[34m";
+
+    /*--------------------------------------------------------*/
+    // statische Attribute(zB. zähler)
+    /*--------------------------------------------------------*/
+
+    /*--------------------------------------------------------*/
+    // Attribute jedes Objektes
+    /*--------------------------------------------------------*/
+
+    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,6 +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

@@ -0,0 +1,28 @@
+/*
+============================================================
+This is the "KartenstapelTest" file from Author: Philipp Kotte
+written on: 10 / 10 / 2023 at: 20:41 
+============================================================
+*/
+package Test.Domain;
+
+import org.junit.Test;
+
+public class KartenstapelTest {
+
+    @Test
+    public void mischenTest() {
+
+    }
+
+    @Test
+    public void getAnzahlKartenTest() {
+
+    }
+
+    @Test
+    public void getObersteKarteTest() {
+
+    }
+
+}

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 {
+import Facade.Spiel;
-    public int id;
+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);
+    }
+
 }