weitere Spielablauf in Spiel.java

Domain/Exceptions/MagierTrumpfException.java

@@ -0,0 +1,14 @@
+/*
+============================================================
+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

@@ -0,0 +1,14 @@
+/*
+============================================================
+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,11 +28,12 @@ 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,7 +6,9 @@ written on: 05 / 10 / 2023 at: 23:28
 */
 package Domain.Karten;
 
-public abstract class Karte {
+import java.io.Serializable;
+
+public abstract class Karte implements Serializable {
 
 	// Statische Konstanten
 

Domain/Karten/Zahlenkarte.java

@@ -44,11 +44,11 @@ public class Zahlenkarte extends Karte {
 	/*------------------------------------------*/
 	// Getter und Setter
 	/*------------------------------------------*/
-	
+
 	public int getId() {
 		return super.getId();
 	}
-	
+
 	public void setFarbe(Kartenfarbe farbe) {
 		this.farbe = farbe;
 	}
@@ -69,6 +69,11 @@ 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,6 +6,7 @@ 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;
@@ -14,22 +15,21 @@ import java.util.HashMap;
 import Domain.Enums.Kartenfarbe;
 import Domain.Karten.*;
 
-
+public class Kartenstapel implements Serializable {
-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<>();
+	private ArrayList<Karte> kartengemischt = new ArrayList<>();
 
 	// Konstruktoren
 	public Kartenstapel() {
@@ -59,7 +59,6 @@ public class Kartenstapel {
 			kartensortiert.put(i, new Zahlenkarte(i, Kartenfarbe.ZWERG, i - 47));
 		}
 
-	
 	}
 	// Statische Methoden
 
@@ -80,7 +79,7 @@ public class Kartenstapel {
 	}
 
 	public Collection<Karte> getKartenstapelGemischt() {
-		return kartengemischt.values();
+		return kartengemischt;
 	}
 
 	/**
@@ -117,13 +116,9 @@ public class Kartenstapel {
 		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));
+			kartengemischt.add(kartensortiert.get(schlüsselzahl));
 			zahlen.remove(index);
 		}
-		
-		for(Karte k : kartengemischt.values()) {
-			System.out.println(k.toString());
-		}
 	}
 
 	/**
@@ -132,13 +127,12 @@ public class Kartenstapel {
 	 * falls noch eine Karte auf dem Stapel liegen sollte. Hierzu wird die Runde,
 	 * als Ausgangswert genommen.
 	 */
-	public Object getObersteKarte() {
+	public Karte getObersteKarte() {
-		Object k = kartengemischt.values().toArray()[0];
+		Karte k = kartengemischt.get(0);
-		kartengemischt.remove(k);
+		kartengemischt.remove(0);
 		return k;
 	}
-	
+
-	
 	/**
 	 * 
 	 */

Domain/Spieler.java

@@ -7,8 +7,11 @@ 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 {
 
@@ -27,6 +30,7 @@ public class Spieler extends Object implements Serializable {
 	private String name;
 	private int vorhersage;
 	private Geschlecht geschlecht;
+	private ArrayList<Karte> karten = new ArrayList<>();
 	//
 
 	/*------------------------------------------*/
@@ -163,6 +167,14 @@ 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
 	/*------------------------------------------*/
@@ -176,7 +188,13 @@ public class Spieler extends Object implements Serializable {
 	 */
 	@Override
 	public String toString() {
-		return "ID: " + this.id + " Name: " + this.name + " (" + this.geschlecht + ")";
+		String temp = "";
+		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,9 +6,13 @@ 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 {
+public class Stich implements Serializable {
     /*------------------------------------------*/
     // statische Konstanten
     /*------------------------------------------*/
@@ -20,9 +24,8 @@ public class Stich {
     /*------------------------------------------*/
     // Attribute jedes Objektes
     /*------------------------------------------*/
-    private Karte[] karten;
+    private ArrayList<Karte> karten;
-    private int[] spielerID;
+    private Kartenfarbe trumpfFarbe;
-    private int kartenCount = 0;
     /*------------------------------------------*/
     // Konstruktoren (default und spezifische)
     /*------------------------------------------*/
@@ -34,6 +37,11 @@ public class Stich {
         setSpielerAnzahl(spielerAnzahl);
     }
 
+    public Stich(int spielerAnzahl, Kartenfarbe trumpKartenfarbe) {
+        setSpielerAnzahl(spielerAnzahl);
+        setTurmpfFarbe(trumpKartenfarbe);
+    }
+
     /*------------------------------------------*/
     // statische Methoden
     /*------------------------------------------*/
@@ -43,18 +51,19 @@ public class Stich {
     /*------------------------------------------*/
 
     public void setSpielerAnzahl(int spielerAnzahl) {
-        this.karten = new Karte[spielerAnzahl];
+        this.karten = new ArrayList<>(spielerAnzahl);
-        this.spielerID = new int[spielerAnzahl];
     }
 
-    public Karte[] getKarten() {
+    public void setTurmpfFarbe(Kartenfarbe trumpfFarbe) {
-        return this.karten;
+        this.trumpfFarbe = trumpfFarbe;
+    }
+
+    public Kartenfarbe getTrumpfFarbe() {
+        return this.trumpfFarbe;
     }
 
     public void addKarte(int spielerID, Karte karte) {
-        this.karten[kartenCount] = karte;
+        this.karten.add(karte);
-        this.spielerID[kartenCount] = spielerID;
-        kartenCount++;
     }
 
     /*------------------------------------------*/
@@ -64,8 +73,8 @@ public class Stich {
     @Override
     public String toString() {
         String text = "";
-        for (int i = 0; i < this.karten.length; i++) {
+        for (int i = 0; i < this.karten.size(); i++) {
-            text += this.karten[i].toString();
+            text += this.karten.get(i).toString();
         }
 
         return text;

Facade/Spiel.java

@@ -7,16 +7,25 @@ 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 {
 
@@ -41,8 +50,8 @@ public class Spiel implements Serializable {
     private boolean istBeendet;
     private Spieler spielerAmZug;
     private int runde;
-    private HashMap<Integer, Spieler> spieler = new HashMap<>();
+    private ArrayList<Spieler> spieler = new ArrayList<>();
-    private HashMap<Integer, Stich> stiche = new HashMap<>();
+    private ArrayList<Stich> stiche = new ArrayList<>();
     private boolean[] id_check = { false, false, false, false, false, false };
     private Kartenstapel kartenstapel;
     private Block block;
@@ -55,16 +64,15 @@ public class Spiel implements Serializable {
         this.istGestartet = false;
         this.istBeendet = false;
         this.spielerAmZug = null;
-        this.runde = 0;
+        this.runde = 1;
         this.kartenstapel = new Kartenstapel();
     };
-    /*--------------------------------------------------------*/
+    /*--------------------------------------------------------
-    // statische Methoden
+     statische Methoden
-    /*--------------------------------------------------------*/
+    --------------------------------------------------------*/
-
+    /*--------------------------------------------------------
-    /*--------------------------------------------------------*/
+    Getter und Setter
-    // Getter und Setter
+    --------------------------------------------------------*/
-    /*--------------------------------------------------------*/
 
     public void setSpielGestartet(boolean gestarted) {
         this.istGestartet = gestarted;
@@ -82,9 +90,9 @@ public class Spiel implements Serializable {
         this.spielerAmZug = spieler;
     }
 
-    /*--------------------------------------------------------*/
+    /*--------------------------------------------------------
-    // @Overrides
+    @Overrides
-    /*--------------------------------------------------------*/
+    --------------------------------------------------------*/
 
     @Override
     public String toString() {
@@ -100,7 +108,7 @@ public class Spiel implements Serializable {
         if (this.spieler.size() == 0) {
             text += "Noch keine Spieler vorhanden \n";
         } else {
-            for (Spieler s : this.spieler.values()) {
+            for (Spieler s : this.spieler) {
                 text += "[" + s.getId() + "] " + s.getName() + " ("
                         + s.getGeschlecht() + ")" + "\n";
 
@@ -118,9 +126,9 @@ public class Spiel implements Serializable {
         return text;
     }
 
-    /*--------------------------------------------------------*/
+    /*--------------------------------------------------------
-    // öffentliche Methodes
+    öffentliche Methodes
-    /*--------------------------------------------------------*/
+    --------------------------------------------------------*/
 
     public void addSpieler(String name, Geschlecht geschlecht) {
         int id = 1;
@@ -129,21 +137,17 @@ public class Spiel implements Serializable {
         }
         id_check[id - 1] = true;
         Spieler temp = new Spieler(id, name, geschlecht);
-        this.spieler.put(id, temp);
+        this.spieler.add(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 {
+    public void removeSpieler(int index) throws SpielerNotFoundException, EmptyListException, RuntimeException {
-        if (this.spieler.containsKey(id_spieler)) {
+        if (this.spieler.size() >= index) {
-            this.spieler.remove(id_spieler);
+            this.spieler.remove(index);
-            this.id_check[id_spieler - 1] = false;
+            this.id_check[index - 1] = false;
-        } else if (!this.spieler.containsKey(id_spieler)) {
+        } else if (this.spieler.size() < index) {
             throw new SpielerNotFoundException("Dieser Spieler existiert nicht");
-        } else if (this.spieler.values().size() == 0) {
+        } else if (this.spieler.size() == 0) {
             throw new EmptyListException("Dise Liste ist Leer.");
         } else {
             throw new RuntimeException("Unkown Error");
@@ -154,52 +158,68 @@ 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.values()) {
+        for (Spieler s : this.spieler) {
             spieler_text[zähler] = s.toString();
             zähler++;
         }
         return spieler_text;
     }
 
-    public void starteSpiel() {
+    public void starteSpiel() throws MagierTrumpfException, NarrenTrumpfException {
         // sing genügend Spieler angelegt?
         if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
             this.istGestartet = true;
-            while (!this.istSpielBeendet()) {
+            erstelleStiche(this.runde);
-                System.out.println("Das Spiel wurde gestartet.");
+            austeilen();
-
+            // Karte k = this.kartenstapel.getObersteKarte();
-                // Beginn der Runde
+            Karte k = new Magierkarte(0);
-                // Stiche erstellen
+            if (k instanceof Magierkarte) {
-                erstelleStiche(this.runde);
+                throw new MagierTrumpfException("Es wurde ein Magier als Trumpf gezogen");
-                // Karten für jeden Spieler verteilen
+            } else if (k instanceof Narrenkarte) {
-
+                setTrumpf(null);
-                // While loop mit der länge der anzahl Stiche für die jeweilige Runde
+                throw new NarrenTrumpfException("Es wurde ein Narr als Trumpf gezogen");
-
+            } else {
-                // Für jeden Durchgang des Loops wird der Stich ermittelt
+                Zahlenkarte zk = (Zahlenkarte) k;
-
+                setTrumpf(zk.getFarbe());
-                // 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++;
             }
+            // 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
+
         } 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() {
-        return new String[1];
+        Spieler s = this.spielerAmZug;
+        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;
     }
@@ -216,18 +236,21 @@ public class Spiel implements Serializable {
         return this.runde;
     }
 
-    public void mischen() {
-
-    }
-
     public void austeilen() {
+        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);
+                }
 
-        // Spieler 1 bekommt karten
+            }
-
+        }
-        // Spieler 2 bekommt Karten
-        // ...
-
-        // letzer Spieler bekommt Karten
 
     }
 
@@ -245,20 +268,42 @@ public class Spiel implements Serializable {
 
     private void erstelleStiche(int runde) {
         for (int i = 0; i < runde; i++) {
-            this.stiche.put(i + 1, new Stich(this.spieler.size()));
+            this.stiche.add(new Stich(this.spieler.size()));
         }
     }
 
-    private void ermittleGewinner(Stich stich) {
+    /*
-        stich.getKarten();
+     * private void ermittleGewinner(Stich stich) {
-    }
+     * stich.getKarten();
+     * }
+     */
 
     private void updateSpielerAmZug() {
         if (this.spieler.size() >= 1) {
-            this.spielerAmZug = (Spieler) this.spieler.values().toArray()[0];
+            this.spielerAmZug = this.spieler.get(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);
+    }
+
+}

UI/SpielCLI.java

@@ -10,8 +10,8 @@ package UI;
 import Facade.Spiel;
 import Domain.Spieler;
 import Domain.Enums.Geschlecht;
-import Domain.Exceptions.EmptyListException;
+import Domain.Enums.Kartenfarbe;
-import Domain.Exceptions.SpielerNotFoundException;
+import Domain.Exceptions.*;
 
 import java.util.Scanner;
 
@@ -72,8 +72,59 @@ public class SpielCLI {
     }
 
     private void spielStarten() {
-        this.spiel.starteSpiel();
+
-        System.out.println("Noch nicht implementiert.");
+        String[] temp = this.spiel.getSpielerAmZug();
+        System.out.println(temp[0] + " ist am Zug.");
+
+        try {
+            this.spiel.starteSpiel();
+        } catch (MagierTrumpfException mte) {
+
+            // 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() {