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

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

.gitignore

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

Domain/Block/Block.java

@@ -6,13 +6,24 @@ written on: 05 / 10 / 2023 at: 23:43
 */
 package Domain.Block;
 
-public class Block {
+import java.util.ArrayList;
-    public void addZeile(){
 
+public class Block {
+    private ArrayList<Blockzeile> zeilen;
+
+    public Block(){
+        this.zeilen = new ArrayList<>();
+    }
+
+    public void addZeile(Blockzeile blockzeile) {
+        zeilen.add(blockzeile);
     }
 
     public Blockzeile[] getDaten(){
-        return null;
+        if(zeilen.isEmpty()){
+            System.out.println("Die Liste der Blockzeilen ist Leer. ");
+            return zeilen.toArray(new Blockzeile[0]);
+        }
+        return zeilen.toArray(new Blockzeile[0]);
     }
-    //neues Kommentar
 }

Domain/Block/Blockeintrag.java

@@ -6,17 +6,25 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
-public class Blockeintrag {
+import Domain.Spieler;
-    public int punkte;
-    public int stiche;
 
+import java.util.Objects;
+
+public class Blockeintrag {
+    private int punkte;
+    private int stiche;
+    private Spieler id;
     public Blockeintrag() {
 
     }
 
-    public Blockeintrag(int punkte, int stiche) {
+    public Blockeintrag(int punkte, int stiche, Spieler id) {
-        this.punkte = punkte;
+        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() {
@@ -28,6 +36,9 @@ public class Blockeintrag {
     }
 
     public void setStiche(int stiche) {
+        if (stiche < 0){
+            throw new IllegalArgumentException("Ihre Stich dürfen nicht im Negative bereich sein");
+        }
         this.stiche = stiche;
     }
 
@@ -35,4 +46,31 @@ public class Blockeintrag {
         this.punkte = punkte;
     }
 
+    public Spieler getId() {
+        return id;
+    }
+
+    @Override
+    public boolean equals(Object ob){
+        if (this == ob) {
+            return true;
+        }
+        if (ob == null || getClass() != ob.getClass()) {
+            return false;
+        }
+
+        Blockeintrag andererEintrag = (Blockeintrag) ob;
+        return this.punkte == andererEintrag.punkte && this.stiche == andererEintrag.stiche
+                && Objects.equals(this.id, andererEintrag.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(punkte, stiche, id);
+    }
+
+    @Override
+    public String toString() {
+        return getPunkte() + ", S: " + getStiche() + " | ";
+    }
 }

Domain/Block/Blockzeile.java

@@ -6,6 +6,8 @@ written on: 05 / 10 / 2023 at: 23:44
 */
 package Domain.Block;
 
+import java.util.ArrayList;
+
 public class Blockzeile {
 
     /*------------------------------------------*/
@@ -21,17 +23,21 @@ public class Blockzeile {
     /*------------------------------------------*/
 
     private int rundenNummer;
-    private Blockeintrag[] eintraege;
+    private ArrayList<Blockeintrag> eintraege;
 
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
 
-    public Blockzeile(int rundenNummer, int spielerAnzahl) {
+    public Blockzeile(){
-        this.rundenNummer = rundenNummer;
+
-        this.eintraege = new Blockeintrag[spielerAnzahl];
     }
 
+    public Blockzeile(int rundenNummer, Blockeintrag eintrag) {
+        this.rundenNummer = rundenNummer;
+        this.eintraege = new ArrayList<>();
+        addEintrag(eintrag);
+    }
     /*------------------------------------------*/
     // statische Methoden
     /*------------------------------------------*/
@@ -39,7 +45,13 @@ public class Blockzeile {
     /*------------------------------------------*/
     // Getter und Setter
     /*------------------------------------------*/
+    public int getRundenNummer() {
+        return rundenNummer;
+    }
 
+    public void setRundenNummer(int rundenNummer) {
+        this.rundenNummer = rundenNummer;
+    }
     /*------------------------------------------*/
     // @Overrides
     /*------------------------------------------*/
@@ -48,21 +60,27 @@ public class Blockzeile {
     // öffentliche Methodes
     /*------------------------------------------*/
 
-    public void addEintrag(Blockeintrag be) {
+    public void addEintrag(Blockeintrag eintrag) {
-
+        if(eintraege != null){
-        for (int i = 0; i < eintraege.length; i++) {
+            eintraege.add(eintrag);
-            if (eintraege[i] == null) {
-                eintraege[i] = be;
-            }
         }
     }
 
     public Blockeintrag[] getDaten() {
-        return eintraege;
+        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/Exceptions/MagierTrumpfException.java

@@ -1,14 +0,0 @@
-/*
-============================================================
-This is the "MagierTrumpfException" file from Author: Philipp Kotte
-written on: 26 / 10 / 2023 at: 15:35 
-============================================================
-*/
-package Domain.Exceptions;
-
-public class MagierTrumpfException extends SpielException {
-
-    public MagierTrumpfException(String message) {
-        super(message);
-    }
-}

Domain/Exceptions/NarrenTrumpfException.java

@@ -1,14 +0,0 @@
-/*
-============================================================
-This is the "NarrenTrumpfException" file from Author: Philipp Kotte
-written on: 26 / 10 / 2023 at: 15:38 
-============================================================
-*/
-package Domain.Exceptions;
-
-public class NarrenTrumpfException extends SpielException {
-
-    public NarrenTrumpfException(String message) {
-        super(message);
-    }
-}

Domain/Exceptions/SpielException.java

@@ -28,12 +28,11 @@ public abstract class SpielException extends Exception {
     }
 
     public SpielException(int id, String message) {
-        this.message = message;
+
-        this.id = id;
     }
 
     public SpielException(String message) {
-        this.message = message;
+
     }
 
     /*------------------------------------------*/

Domain/Karten/Karte.java

@@ -6,9 +6,7 @@ written on: 05 / 10 / 2023 at: 23:28
 */
 package Domain.Karten;
 
-import java.io.Serializable;
+public abstract class Karte {
-
-public abstract class Karte implements Serializable {
 
 	// Statische Konstanten
 

Domain/Karten/Zahlenkarte.java

@@ -69,11 +69,6 @@ public class Zahlenkarte extends Karte {
 	// @Overrides
 	/*------------------------------------------*/
 
-	@Override
-	public String toString() {
-		return "ID: " + this.getId() + " Typ: " + this.getFarbe() + " Wert: " + this.getKartenNummer();
-	}
-
 	/*------------------------------------------*/
 	// öffentliche Methodes
 	/*------------------------------------------*/

Domain/Kartenstapel.java

@@ -6,7 +6,6 @@ written on: 05 / 10 / 2023 at: 23:42
 */
 package Domain;
 
-import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -15,7 +14,8 @@ import java.util.HashMap;
 import Domain.Enums.Kartenfarbe;
 import Domain.Karten.*;
 
-public class Kartenstapel implements Serializable {
+
+public class Kartenstapel {
 
 	// Statische Konstanten
 
@@ -29,7 +29,7 @@ public class Kartenstapel implements Serializable {
 	 */
 	private HashMap<Integer, Karte> kartensortiert = new HashMap<>();
 
-	private ArrayList<Karte> kartengemischt = new ArrayList<>();
+	private HashMap<Integer, Karte> kartengemischt = new HashMap<>();
 
 	// Konstruktoren
 	public Kartenstapel() {
@@ -59,6 +59,7 @@ public class Kartenstapel implements Serializable {
 			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
 		}
 
+	
 	}
 	// Statische Methoden
 
@@ -79,7 +80,7 @@ public class Kartenstapel implements Serializable {
 	}
 
 	public Collection<Karte> getKartenstapelGemischt() {
-		return kartengemischt;
+		return kartengemischt.values();
 	}
 
 	/**
@@ -116,9 +117,13 @@ public class Kartenstapel implements Serializable {
 		for (int i = 0; i < 60; i++) {
 			int index = zufall.nextInt(zahlen.size());
 			int schlüsselzahl = zahlen.get(index);
-			kartengemischt.add(kartensortiert.get(schlüsselzahl));
+			kartengemischt.put(i + 1, kartensortiert.get(schlüsselzahl));
 			zahlen.remove(index);
 		}
+		
+		for(Karte k : kartengemischt.values()) {
+			System.out.println(k.toString());
+		}
 	}
 
 	/**
@@ -127,12 +132,13 @@ public class Kartenstapel implements Serializable {
 	 * falls noch eine Karte auf dem Stapel liegen sollte. Hierzu wird die Runde,
 	 * als Ausgangswert genommen.
 	 */
-	public Karte getObersteKarte() {
+	public Object getObersteKarte() {
-		Karte k = kartengemischt.get(0);
+		Object k = kartengemischt.values().toArray()[0];
-		kartengemischt.remove(0);
+		kartengemischt.remove(k);
 		return k;
 	}
 	
+	
 	/**
 	 * 
 	 */

Domain/Spieler.java

@@ -7,11 +7,8 @@ written on: 05 / 10 / 2023 at: 23:48
 package Domain;
 
 import Domain.Enums.Geschlecht;
-import Domain.Karten.Karte;
 
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashMap;
 
 public class Spieler extends Object implements Serializable {
 
@@ -30,7 +27,6 @@ public class Spieler extends Object implements Serializable {
 	private String name;
 	private int vorhersage;
 	private Geschlecht geschlecht;
-	private ArrayList<Karte> karten = new ArrayList<>();
 	//
 
 	/*------------------------------------------*/
@@ -167,14 +163,6 @@ public class Spieler extends Object implements Serializable {
 		return vorhersage;
 	}
 
-	public void addKarte(Karte k) {
-		this.karten.add(k);
-	}
-
-	public Karte[] getHandKarte() {
-		return (Karte[]) this.karten.toArray();
-	}
-
 	/*------------------------------------------*/
 	// @Overrides
 	/*------------------------------------------*/
@@ -188,13 +176,7 @@ public class Spieler extends Object implements Serializable {
 	 */
 	@Override
 	public String toString() {
-		String temp = "";
+		return "ID: " + this.id + " Name: " + this.name + " (" + this.geschlecht + ")";
-		temp += "ID: " + this.getId() + "\n";
-		temp += "Name: " + this.getName() + "(" + this.getGeschlecht() + ")" + "\n";
-		for (Karte k : this.karten) {
-			temp += k.toString() + "\n";
-		}
-		return temp;
 	}
 
 	/*------------------------------------------*/

Domain/Stich.java

@@ -6,13 +6,9 @@ written on: 11 / 10 / 2023 at: 20:25
 */
 package Domain;
 
-import java.io.Serializable;
-import java.util.ArrayList;
-
-import Domain.Enums.Kartenfarbe;
 import Domain.Karten.Karte;
 
-public class Stich implements Serializable {
+public class Stich {
     /*------------------------------------------*/
     // statische Konstanten
     /*------------------------------------------*/
@@ -24,8 +20,9 @@ public class Stich implements Serializable {
     /*------------------------------------------*/
     // Attribute jedes Objektes
     /*------------------------------------------*/
-    private ArrayList<Karte> karten;
+    private Karte[] karten;
-    private Kartenfarbe trumpfFarbe;
+    private int[] spielerID;
+    private int kartenCount = 0;
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
@@ -37,11 +34,6 @@ public class Stich implements Serializable {
         setSpielerAnzahl(spielerAnzahl);
     }
 
-    public Stich(int spielerAnzahl, Kartenfarbe trumpKartenfarbe) {
-        setSpielerAnzahl(spielerAnzahl);
-        setTurmpfFarbe(trumpKartenfarbe);
-    }
-
     /*------------------------------------------*/
     // statische Methoden
     /*------------------------------------------*/
@@ -51,19 +43,18 @@ public class Stich implements Serializable {
     /*------------------------------------------*/
 
     public void setSpielerAnzahl(int spielerAnzahl) {
-        this.karten = new ArrayList<>(spielerAnzahl);
+        this.karten = new Karte[spielerAnzahl];
+        this.spielerID = new int[spielerAnzahl];
     }
 
-    public void setTurmpfFarbe(Kartenfarbe trumpfFarbe) {
+    public Karte[] getKarten() {
-        this.trumpfFarbe = trumpfFarbe;
+        return this.karten;
-    }
-
-    public Kartenfarbe getTrumpfFarbe() {
-        return this.trumpfFarbe;
     }
 
     public void addKarte(int spielerID, Karte karte) {
-        this.karten.add(karte);
+        this.karten[kartenCount] = karte;
+        this.spielerID[kartenCount] = spielerID;
+        kartenCount++;
     }
 
     /*------------------------------------------*/
@@ -73,8 +64,8 @@ public class Stich implements Serializable {
     @Override
     public String toString() {
         String text = "";
-        for (int i = 0; i < this.karten.size(); i++) {
+        for (int i = 0; i < this.karten.length; i++) {
-            text += this.karten.get(i).toString();
+            text += this.karten[i].toString();
         }
 
         return text;

Facade/Spiel.java

@@ -7,25 +7,16 @@ written on: 05 / 10 / 2023 at: 23:25
 package Facade;
 
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
-import java.util.Scanner;
 
 import Domain.Kartenstapel;
 import Domain.Spieler;
 import Domain.Stich;
 import Domain.Block.Block;
 import Domain.Enums.Geschlecht;
-import Domain.Enums.Kartenfarbe;
 import Domain.Exceptions.EmptyListException;
-import Domain.Exceptions.MagierTrumpfException;
-import Domain.Exceptions.NarrenTrumpfException;
 import Domain.Exceptions.SpielerNotFoundException;
 import Domain.Karten.Karte;
-import Domain.Karten.Magierkarte;
-import Domain.Karten.Narrenkarte;
-import Domain.Karten.Zahlenkarte;
 
 public class Spiel implements Serializable {
 
@@ -50,8 +41,8 @@ public class Spiel implements Serializable {
     private boolean istBeendet;
     private Spieler spielerAmZug;
     private int runde;
-    private ArrayList<Spieler> spieler = new ArrayList<>();
+    private HashMap<Integer, Spieler> spieler = new HashMap<>();
-    private ArrayList<Stich> stiche = new ArrayList<>();
+    private HashMap<Integer, Stich> stiche = new HashMap<>();
     private boolean[] id_check = { false, false, false, false, false, false };
     private Kartenstapel kartenstapel;
     private Block block;
@@ -64,15 +55,16 @@ public class Spiel implements Serializable {
         this.istGestartet = false;
         this.istBeendet = false;
         this.spielerAmZug = null;
-        this.runde = 1;
+        this.runde = 0;
         this.kartenstapel = new Kartenstapel();
     };
-    /*--------------------------------------------------------
+    /*--------------------------------------------------------*/
-     statische Methoden
+    // statische Methoden
-    --------------------------------------------------------*/
+    /*--------------------------------------------------------*/
-    /*--------------------------------------------------------
+
-    Getter und Setter
+    /*--------------------------------------------------------*/
-    --------------------------------------------------------*/
+    // Getter und Setter
+    /*--------------------------------------------------------*/
 
     public void setSpielGestartet(boolean gestarted) {
         this.istGestartet = gestarted;
@@ -90,9 +82,9 @@ public class Spiel implements Serializable {
         this.spielerAmZug = spieler;
     }
 
-    /*--------------------------------------------------------
+    /*--------------------------------------------------------*/
-    @Overrides
+    // @Overrides
-    --------------------------------------------------------*/
+    /*--------------------------------------------------------*/
 
     @Override
     public String toString() {
@@ -108,7 +100,7 @@ public class Spiel implements Serializable {
         if (this.spieler.size() == 0) {
             text += "Noch keine Spieler vorhanden \n";
         } else {
-            for (Spieler s : this.spieler) {
+            for (Spieler s : this.spieler.values()) {
                 text += "[" + s.getId() + "] " + s.getName() + " ("
                         + s.getGeschlecht() + ")" + "\n";
 
@@ -126,9 +118,9 @@ public class Spiel implements Serializable {
         return text;
     }
 
-    /*--------------------------------------------------------
+    /*--------------------------------------------------------*/
-    öffentliche Methodes
+    // öffentliche Methodes
-    --------------------------------------------------------*/
+    /*--------------------------------------------------------*/
 
     public void addSpieler(String name, Geschlecht geschlecht) {
         int id = 1;
@@ -137,17 +129,21 @@ public class Spiel implements Serializable {
         }
         id_check[id - 1] = true;
         Spieler temp = new Spieler(id, name, geschlecht);
-        this.spieler.add(temp);
+        this.spieler.put(id, temp);
+        System.out.println(this.spieler.get(id));
+        if (this.spielerAmZug == null) {
+            this.spielerAmZug = temp;
+        }
         updateSpielerAmZug();
     }
 
-    public void removeSpieler(int index) throws SpielerNotFoundException, EmptyListException, RuntimeException {
+    public void removeSpieler(int id_spieler) throws SpielerNotFoundException, EmptyListException, RuntimeException {
-        if (this.spieler.size() >= index) {
+        if (this.spieler.containsKey(id_spieler)) {
-            this.spieler.remove(index);
+            this.spieler.remove(id_spieler);
-            this.id_check[index - 1] = false;
+            this.id_check[id_spieler - 1] = false;
-        } else if (this.spieler.size() < index) {
+        } else if (!this.spieler.containsKey(id_spieler)) {
             throw new SpielerNotFoundException("Dieser Spieler existiert nicht");
-        } else if (this.spieler.size() == 0) {
+        } else if (this.spieler.values().size() == 0) {
             throw new EmptyListException("Dise Liste ist Leer.");
         } else {
             throw new RuntimeException("Unkown Error");
@@ -158,30 +154,25 @@ public class Spiel implements Serializable {
     public String[] getAlleSpieler() {
         String[] spieler_text = new String[this.spieler.size()];
         int zähler = 0;
-        for (Spieler s : this.spieler) {
+        for (Spieler s : this.spieler.values()) {
             spieler_text[zähler] = s.toString();
             zähler++;
         }
         return spieler_text;
     }
 
-    public void starteSpiel() throws MagierTrumpfException, NarrenTrumpfException {
+    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);
-            austeilen();
+                // Karten für jeden Spieler verteilen
-            // Karte k = this.kartenstapel.getObersteKarte();
+
-            Karte k = new Magierkarte(0);
-            if (k instanceof Magierkarte) {
-                throw new MagierTrumpfException("Es wurde ein Magier als Trumpf gezogen");
-            } else if (k instanceof Narrenkarte) {
-                setTrumpf(null);
-                throw new NarrenTrumpfException("Es wurde ein Narr als Trumpf gezogen");
-            } else {
-                Zahlenkarte zk = (Zahlenkarte) k;
-                setTrumpf(zk.getFarbe());
-            }
                 // While loop mit der länge der anzahl Stiche für die jeweilige Runde
 
                 // Für jeden Durchgang des Loops wird der Stich ermittelt
@@ -193,33 +184,22 @@ public class Spiel implements Serializable {
                 // 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");
         }
 
     }
 
-    /**
-     * Gibt den Spieler zurück, der am Zug ist.
-     * 
-     * @return String[] -> name, id, geschlecht, vorhersage
-     */
     public String[] getSpielerAmZug() {
-        Spieler s = this.spielerAmZug;
+        return new String[1];
-        String[] temp = { s.getName(), "" + s.getId(), s.getGeschlecht().toString(), "" + s.getVorhersage() };
-        return temp;
     }
 
     public boolean istSpielGestartet() {
         return this.istGestartet;
     }
 
-    public void setTrumpf(Kartenfarbe kf) {
-        Stich s = (Stich) this.stiche.get(0);
-        s.setTurmpfFarbe(kf);
-    }
-
     public boolean istSpielBeendet() {
         return this.istBeendet;
     }
@@ -236,21 +216,18 @@ public class Spiel implements Serializable {
         return this.runde;
     }
 
-    public void austeilen() {
+    public void mischen() {
-        this.kartenstapel.mischen();
-        for (int i = 0; i < this.runde; i++) {
-            for (Spieler s : this.spieler) {
-                Karte k = this.kartenstapel.getObersteKarte();
-                if (k instanceof Magierkarte) {
-                    s.addKarte(((Magierkarte) k));
-                } else if (k instanceof Zahlenkarte) {
-                    s.addKarte(((Zahlenkarte) k));
-                } else {
-                    s.addKarte((Narrenkarte) k);
-                }
 
     }
-        }
+
+    public void austeilen() {
+
+        // Spieler 1 bekommt karten
+
+        // Spieler 2 bekommt Karten
+        // ...
+
+        // letzer Spieler bekommt Karten
 
     }
 
@@ -268,42 +245,20 @@ public class Spiel implements Serializable {
 
     private void erstelleStiche(int runde) {
         for (int i = 0; i < runde; i++) {
-            this.stiche.add(new Stich(this.spieler.size()));
+            this.stiche.put(i + 1, new Stich(this.spieler.size()));
         }
     }
 
-    /*
+    private void ermittleGewinner(Stich stich) {
-     * private void ermittleGewinner(Stich stich) {
+        stich.getKarten();
-     * stich.getKarten();
+    }
-     * }
-     */
 
     private void updateSpielerAmZug() {
         if (this.spieler.size() >= 1) {
-            this.spielerAmZug = this.spieler.get(0);
+            this.spielerAmZug = (Spieler) this.spieler.values().toArray()[0];
         } else {
             this.spielerAmZug = null;
         }
     }
 
-    private void updateSpielerList(Spieler gewinner) {
-        ArrayList<Spieler> temp = new ArrayList<>(this.spieler.size());
-        int start = 0;
-        for (int i = 0; i < this.spieler.size(); i++) {
-            if (this.spieler.get(i) == gewinner) {
-                start = i;
-            }
-        }
-
-        for (int i = start; i < this.spieler.size(); i++) {
-            temp.add(this.spieler.get(i));
-        }
-        for (int i = 0; i < start; i++) {
-            temp.add(this.spieler.get(i));
-        }
-
-        this.spieler = temp;
-        this.spielerAmZug = temp.get(0);
-    }
-
 }

Test/Domain/Block/BlockTest.java

@@ -6,6 +6,96 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
+import Domain.Block.Block;
+import Domain.Block.Blockeintrag;
+import Domain.Block.Blockzeile;
+import Domain.Enums.Geschlecht;
+import Facade.Spiel;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+
 public class BlockTest {
+    Block block = new Block();
+    Blockeintrag b1 = new Blockeintrag(20,0,null);
+    Blockeintrag b2 = new Blockeintrag(30,1,null);
+    Blockeintrag b3 = new Blockeintrag(40,2,null);
+    Blockeintrag b4 = new Blockeintrag(20,0,null);
+    Blockeintrag b5 = new Blockeintrag(30,1,null);
+    Blockeintrag b6 = new Blockeintrag(40,2,null);
+
+    Blockzeile z1 = new Blockzeile(1,b1);
+    Blockzeile z2 = new Blockzeile(2,b2);
+    Blockzeile z3 = new Blockzeile(3, b3);
+    Blockzeile z4 = new Blockzeile(1,b1);
+    Blockzeile z5 = new Blockzeile(2,b2);
+    Blockzeile z6 = new Blockzeile(3, b3);
+
+    /**
+     * Testet die Methode addZeile in der Block-Klasse.
+     * Überprüft, ob die Anzahl der Zeilen im Block nach dem Hinzufügen korrekt ist
+     * und ob die hinzugefügte Zeile an der richtigen Position im Datenarray steht.
+     */
+    @Test
+    public void addZeileTest() {
+        block.addZeile(z1);
+        block.addZeile(z2);
+        block.addZeile(z3);
+
+        z1.addEintrag(b1);
+        z1.addEintrag(b2);
+        z1.addEintrag(b3);
+        z2.addEintrag(b1);
+        z2.addEintrag(b2);
+        z2.addEintrag(b3);
+        z3.addEintrag(b1);
+        z3.addEintrag(b2);
+        z3.addEintrag(b3);
+
+        assertEquals(3,block.getDaten().length);
+        assertTrue((z1 == block.getDaten()[0]) &&
+                (z2 == block.getDaten()[1]) && (z3 == block.getDaten()[2]));
 
     }
+
+    /**
+     * Testet die Methode getDaten der Klasse Block. Überprüft, ob die Daten im
+     * Block korrekt abgerufen werden können.
+     */
+    @Test
+    public void getDatenTest() {
+        block.addZeile(z4);
+        block.addZeile(z5);
+        block.addZeile(z6);
+
+        z1.addEintrag(b4);
+        z1.addEintrag(b5);
+        z1.addEintrag(b6);
+        z2.addEintrag(b4);
+        z2.addEintrag(b5);
+        z2.addEintrag(b6);
+        z3.addEintrag(b4);
+        z3.addEintrag(b5);
+        z3.addEintrag(b6);
+
+        assertTrue((block.getDaten()[0].getDaten()[0].getPunkte() ==20)
+        && (block.getDaten()[0].getDaten()[0].getStiche() == 0)
+        && (block.getDaten()[1].getDaten()[0].getPunkte() == 30)
+        && (block.getDaten()[1].getDaten()[0].getStiche() == 1)
+        && (block.getDaten()[2].getDaten()[0].getPunkte() == 40)
+        && (block.getDaten()[2].getDaten()[0].getStiche() == 2));
+
+    }
+
+    /**
+     * Testet die Methode getDaten der Klasse Block für einen leeren Block.
+     * Überprüft, ob für einen leeren Block ein leeres Datenarray zurückgegeben
+     * wird.
+     */
+    @Test
+    public void getDatenTestLeererBlock(){
+        Block block2 = new Block();
+        assertEquals(0, block2.getDaten().length);
+    }
+}

Test/Domain/Block/BlockeintragTest.java

@@ -6,6 +6,39 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockeintragTest {
+import Domain.Block.Blockeintrag;
+import org.junit.Test;
 
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+public class BlockeintragTest {
+    @Test
+    public void getPunkteTest(){
+        Blockeintrag eintrag = new Blockeintrag(20,0,null);
+        assertTrue((eintrag.getPunkte() == 20));
+        eintrag.setPunkte(30);
+        assertTrue((eintrag.getPunkte() == 30));
+        eintrag.setPunkte(40);
+        assertTrue((eintrag.getPunkte()== 40));
+    }
+
+    @Test
+    public void getStiche() {
+        Blockeintrag eintrag = new Blockeintrag(30,1,null);
+        assertEquals(1, eintrag.getStiche());
+        eintrag.setStiche(2);
+        assertEquals(2, eintrag.getStiche());
+        eintrag.setStiche(3);
+        assertEquals(3, eintrag.getStiche());
+    }
+
+    //Exception Test hier schreiben
+    @Test
+    public void testNegativeStiche() throws Exception {
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(50, -3, null));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(30,-1, null));
+        assertThrows(IllegalArgumentException.class, () -> new Blockeintrag(10, -4, null));
+    }
 }

Test/Domain/Block/BlockzeileTest.java

@@ -6,6 +6,102 @@ written on: 10 / 10 / 2023 at: 21:17
 */
 package Test.Domain.Block;
 
-public class BlockzeileTest {
+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

@@ -7,41 +7,33 @@ 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.Enums.Kartenfarbe;
 import Domain.Karten.Magierkarte;
 
-/**
- * 
- * @author sellm
- * @version
- * 
- *
- */
 
 public class MagierkarteTest {
 
+	
 	@Test
 	public void vierMagier() {
-		Magierkarte m1 = new Magierkarte(Kartenfarbe.MENSCH, "Zauberer");
+		Magierkarte m1 = new Magierkarte(1);
-		Magierkarte m2 = new Magierkarte(Kartenfarbe.ELF, "Zauberer");
+		Magierkarte m2 = new Magierkarte(2);
-		Magierkarte m3 = new Magierkarte(Kartenfarbe.RIESE, "Zauberer");
+		Magierkarte m3 = new Magierkarte(3);
-		Magierkarte m4 = new Magierkarte(Kartenfarbe.ZWERG, "Zauberer");
+		Magierkarte m4 = new Magierkarte(4);
 
-		assertEquals(Kartenfarbe.MENSCH, m1.getKartenfarbe());
-		assertEquals("Zauberer", m1.getBezeichnung());
-		assertEquals("BLAU", Kartenfarbe.MENSCH.getFarbe());
-		assertEquals(Kartenfarbe.ELF, m2.getKartenfarbe());
-		assertEquals("Zauberer", m2.getBezeichnung());
-		assertEquals("GRÜN", Kartenfarbe.ELF.getFarbe());
-		assertEquals(Kartenfarbe.RIESE, m3.getKartenfarbe());
-		assertEquals("Zauberer", m3.getBezeichnung());
-		assertEquals("GELB", Kartenfarbe.RIESE.getFarbe());
-		assertEquals(Kartenfarbe.ZWERG, m4.getKartenfarbe());
-		assertEquals("Zauberer", m4.getBezeichnung());
-		assertEquals("ROT", Kartenfarbe.ZWERG.getFarbe());
 		
-		assertEquals("Zauberer: MENSCH (BLAU).", m1.toString());
+		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

@@ -7,34 +7,33 @@ 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.Enums.Kartenfarbe;
 import Domain.Karten.Narrenkarte;
 
 public class NarrenkarteTest {
 
+	
 	@Test
 	public void vierNarren() {
-		Narrenkarte n1 = new Narrenkarte(Kartenfarbe.MENSCH, "Narr");
+		Narrenkarte n1 = new Narrenkarte(5);
-		Narrenkarte n2 = new Narrenkarte(Kartenfarbe.ELF, "Narr");
+		Narrenkarte n2 = new Narrenkarte(6);
-		Narrenkarte n3 = new Narrenkarte(Kartenfarbe.RIESE, "Narr");
+		Narrenkarte n3 = new Narrenkarte(7);
-		Narrenkarte n4 = new Narrenkarte(Kartenfarbe.ZWERG, "Narr");
+		Narrenkarte n4 = new Narrenkarte(8);
 
-		assertEquals(n1.getKartenfarbe(), Kartenfarbe.MENSCH);
+		assertEquals(n1.getName(), "Narr");
-		assertEquals(n2.getKartenfarbe(), Kartenfarbe.ELF);
+		assertTrue(5 == n1.getId());
-		assertEquals(n3.getKartenfarbe(), Kartenfarbe.RIESE);
+		assertEquals(n2.getName(), "Narr");
-		assertEquals(n4.getKartenfarbe(), Kartenfarbe.ZWERG);
+		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());
 
-		assertEquals(n1.getBezeichnung(), "Narr");
-		assertEquals(n2.getBezeichnung(), "Narr");
-		assertEquals(n3.getBezeichnung(), "Narr");
-		assertEquals(n4.getBezeichnung(), "Narr");
 		
-		assertEquals(Kartenfarbe.MENSCH.getFarbe(), "BLAU");
-		assertEquals(Kartenfarbe.ELF.getFarbe(), "GRÜN");
-		assertEquals(Kartenfarbe.RIESE.getFarbe(), "GELB");
-		assertEquals(Kartenfarbe.ZWERG.getFarbe(), "ROT");
 	}
 }

Test/Domain/Karten/ZahlenkarteTest.java

@@ -7,81 +7,81 @@ 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 {
 
-	/**
-	 * Die Objekterzeugung der HashMap und der Zahlenkarten
-	 * kann auch in ein @BeforeAll eingetragen werden.
-	 */
-
-	/**
-	 * Der @Test erzeugt Zahlenkarten von 1 bis 13. prüft aber
-	 * nur zwei Positionen in der HashMap, um die
-	 * Objektdaten zu validieren.
-	 */
-	@Test
-	public void dreizehnZahlenkartenMENSCH() {
-
-		HashMap<Integer, Zahlenkarte> zm = new HashMap<Integer, Zahlenkarte>();
-		Zahlenkarte zahlenkarte = null;
-		for (int i = 1; i <= 13; i++) {
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.MENSCH, i);
-			zm.put(i, zahlenkarte);
-		}
-
-		assertEquals(zm.get(7).getKartenNummer(), 7);
-
-		assertEquals(zm.get(4).getKartenNummer(), 4);
-	}
 	
 	@Test
-	public void dreizehnZahlenkartenElf() {
+	public void zahlenkartentesten() {
-		HashMap<Integer, Zahlenkarte> ze = new HashMap<Integer, Zahlenkarte>();
+		
-		Zahlenkarte zahlenkarte = null;
+		HashMap<Integer, Karte> zk = new HashMap<>();
-		for (int i = 1; i <= 13; i++) {
+		
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.ELF, i);
+		for (int i = 1; i <= 8; i++) {
-			ze.put(i, zahlenkarte);
+			zk.put(i, null);
 		}
 		
-		assertEquals(ze.get(7).getKartenNummer(), 7);
+		for (int i = 9; i <= 21; i++) {
-
+			zk.put(i, new Zahlenkarte(i, Kartenfarbe.MENSCH, i - 8));
-		assertEquals(ze.get(4).getKartenNummer(), 4);
+		}
+		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));
 		}
 		
-	@Test
+		// Testen der Charakterkarten MENSCH
-	public void dreizehnZahlenkartenZWERG() {
+		assertEquals(1, ((Zahlenkarte) zk.get(9)).getKartenNummer());
-		HashMap<Integer, Zahlenkarte> zz = new HashMap<Integer, Zahlenkarte>();
+		assertEquals(13, ((Zahlenkarte) zk.get(21)).getKartenNummer());
-		Zahlenkarte zahlenkarte = null;
+		assertEquals(5, ((Zahlenkarte) zk.get(13)).getKartenNummer());
-		for (int i = 1; i <= 13; i++) {
+		
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.ZWERG, i);
+		assertEquals(17, ((Zahlenkarte) zk.get(17)).getId());
-			zz.put(i, zahlenkarte);
+		
-		}
+		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());
 		
-		assertEquals(zz.get(7).getKartenNummer(), 7);
 		
-		assertEquals(zz.get(4).getKartenNummer(), 4);
 		
 	}	
 		
-	@Test
-	public void dreizehnZahlenkartenRIESE() {
-		HashMap<Integer, Zahlenkarte> zr = new HashMap<Integer, Zahlenkarte>();
-		Zahlenkarte zahlenkarte = null;
-		for (int i = 1; i <= 13; i++) {
-			zahlenkarte = new Zahlenkarte(Kartenfarbe.RIESE, i);
-			zr.put(i, zahlenkarte);
-		}
 
-		assertEquals(zr.get(9).getKartenNummer(), 9);
-
-		assertEquals(zr.get(2).getKartenNummer(), 2);
-	}
 }

UI/SpielCLI.java

@@ -10,8 +10,8 @@ package UI;
 import Facade.Spiel;
 import Domain.Spieler;
 import Domain.Enums.Geschlecht;
-import Domain.Enums.Kartenfarbe;
+import Domain.Exceptions.EmptyListException;
-import Domain.Exceptions.*;
+import Domain.Exceptions.SpielerNotFoundException;
 
 import java.util.Scanner;
 
@@ -72,59 +72,8 @@ public class SpielCLI {
     }
 
     private void spielStarten() {
-
-        String[] temp = this.spiel.getSpielerAmZug();
-        System.out.println(temp[0] + " ist am Zug.");
-
-        try {
         this.spiel.starteSpiel();
-        } catch (MagierTrumpfException mte) {
+        System.out.println("Noch nicht implementiert.");
-
-            // Karten werden verteilt und trumpf wird festgelegt
-
-            System.out.println(mte.getMessage());
-            System.out.println(temp[0] + " darf den Trumpf aussuchen.\n");
-            boolean valid = false;
-            while (!valid) {
-                System.out.println("[1] Elf, [2] Mensch, [3] Zwerg, [4] Riese ");
-                int choice;
-                try {
-                    choice = Integer.parseInt(sc.nextLine());
-                    switch (choice) {
-                        case 1:
-                            spiel.setTrumpf(Kartenfarbe.ELF);
-                            valid = true;
-                            break;
-                        case 2:
-                            spiel.setTrumpf(Kartenfarbe.MENSCH);
-                            valid = true;
-                            break;
-                        case 3:
-                            spiel.setTrumpf(Kartenfarbe.ZWERG);
-                            valid = true;
-                            break;
-                        case 4:
-                            spiel.setTrumpf(Kartenfarbe.RIESE);
-                            valid = true;
-                            break;
-                        default:
-                            System.out.println("Diese Auswahl ist nicht erlaub");
-                            break;
-
-                    }
-                } catch (NumberFormatException nfe) {
-                    System.out.println("Dies war keine Nummer");
-                }
-            }
-        } catch (NarrenTrumpfException nte) {
-            System.out.println(nte.getMessage());
-            System.out.println("Diese Runde wird ohne Trumpf gespielt.");
-        }
-
-    }
-
-    private void treffeVorhersage() {
-        System.out.println("");
     }
 
     private void addSpieler() {