update

Domain/Karten/Karte.java

@@ -27,4 +27,6 @@ public abstract class Karte {
 		kartenId++;
 	}
 
+	public abstract String getName();
+	
 }

Domain/Karten/Test/KarteTest.java

@@ -1,14 +0,0 @@
-package Domain.Karten.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-import org.junit.jupiter.api.Test;
-
-class KarteTest {
-
-	@Test
-	void kartenAnzahl() {
-		
-	}
-
-}

Domain/Karten/Zahlenkarte.java

@@ -11,7 +11,7 @@ import Domain.Enums.Kartenfarbe;
 public class Zahlenkarte extends Karte {
 
 	// Statische Konstanten
-	
+	private final static String NAME = "Charakterkarte";
 	// Statische Attribute
 	private static int menschID = 1;
 	private static int elfID = 1;
@@ -20,6 +20,7 @@ public class Zahlenkarte extends Karte {
 	// Attribute der Objekte
 	private int kartenwert;
 	private Kartenfarbe charakter;
+	private String name;
 	// Konstruktoren
 	
 	public Zahlenkarte(Kartenfarbe farbe) {
@@ -58,6 +59,10 @@ public class Zahlenkarte extends Karte {
 	public void setCharakter(Kartenfarbe charakter) {
 		this.charakter = charakter;
 	}
+	
+	public void setName() {
+		this.name = NAME;
+	}
 	// Overrides
 	
 	// Public Methoden
@@ -66,24 +71,34 @@ public class Zahlenkarte extends Karte {
 	private void setNeueMenschKarte(Kartenfarbe farbe) {
 		setCharakter(farbe);
 		setKartenwert(menschID);
+		setName();
 		menschID++;
 	}
 
 	private void setNeueElfKarte(Kartenfarbe farbe) {
 		setCharakter(farbe);
 		setKartenwert(elfID);
+		setName();
 		elfID++;
 	}
 	
 	private void setNeueRieseKarte(Kartenfarbe farbe) {
 		setCharakter(farbe);
 		setKartenwert(rieseID);
+		setName();
 		rieseID++;
 	}
 	
 	private void setNeueZwergKarte(Kartenfarbe farbe) {
 		setCharakter(farbe);
 		setKartenwert(zwergID);
+		setName();
 		zwergID++;
 	}
+
+	@Override
+	public String getName() {
+		// TODO Auto-generated method stub
+		return this.name;
+	}
 }

Domain/Kartenstapel.java

@@ -6,6 +6,150 @@ written on: 05 / 10 / 2023 at: 23:42
 */
 package Domain;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+
+import Domain.Enums.Kartenfarbe;
+import Domain.Karten.Karte;
+import Domain.Karten.Magierkarte;
+import Domain.Karten.Narrenkarte;
+import Domain.Karten.Zahlenkarte;
+import Facade.Spiel;
+
 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() {
+		if (Karte.getKartenId() != 60) {
+			// Erstelle Magierkarten
+			for (int i = 1; i <= 4; i++) {
+				kartensortiert.put(i, new Magierkarte());
+			}
+			// Erstelle Narrenkarten
+			for (int i = 5; i <= 8; i++) {
+				kartensortiert.put(i, new Narrenkarte());
+			}
+			// Erstelle Charakterkarten MENSCH
+			for (int i = 9; i <= 21; i++) {
+				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.MENSCH));
+			}
+			// Erstelle Charakterkarten ELF
+			for (int i = 22; i <= 34; i++) {
+				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.ELF));
+			}
+			// Erstelle Charakterkarten RIESE
+			for (int i = 35; i <= 47; i++) {
+				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.RIESE));
+			}
+			// Erstelle Charakterkarten ZWERG
+			for (int i = 48; i <= 60; i++) {
+				kartensortiert.put(i, new Zahlenkarte(Kartenfarbe.ZWERG));
+			}
+
+		}
+	}
+	// 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).getName()));
+		}
+		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);
+		}
+	}
+
+	/**
+	 * 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 Karte getObersteKarte() {
+		Karte austeilen = null;
+		if (kartengemischt.get(kartenzählen) != null && kartenzählen <= 60) {
+			
+			austeilen = kartengemischt.get(kartenzählen);
+			kartengemischt.remove(kartenzählen);
+			kartenzählen++;
+			
+		} 
+		else if (kartenzählen > 60) {
+			throw new RuntimeException("Es können nicht mehr als 60 Karten ausgeteilt werden.");
+		}
+		else {
+			throw new RuntimeException("Es ist ein Fehler in 'Kartenzählen' aufgetaucht.");
+		}
+
+		return austeilen;
+	}
+	// Private Methoden
+
 }

Facade/Spiel.java

@@ -8,4 +8,9 @@ package Facade;
 
 public class Spiel {
 
+	public static int getRunde() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
 }

Infrastructure/Persistenz.java

@@ -8,4 +8,5 @@ package Infrastructure;
 
 public class Persistenz {
 
+	
 }

Test/Domain/KartenstapelTest.java

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