update

Domain/Enums/Geschlecht.java

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

Domain/Enums/Kartenfarbe.java

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

Domain/Hand.java

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

Domain/Karten/Karte.java

@@ -6,6 +6,45 @@ written on: 05 / 10 / 2023 at: 23:28
 */
 package Domain.Karten;
 
-public class Karte {
+public abstract class Karte {
+	
+	// Statische Konstanten
+	
+	// Statische Attribute
+	private static int kartenId = 0;
+	
+	// Attribute der Objekte (Kann es keine geben, da die Klasse abstrakt ist)
+	
+	// Konstruktoren
+	public Karte() {
+		if (kartenId <= 60) {
+			setKartenId();
+		}
+		else {
+			throw new RuntimeException("Es darf nur 60 Karten im Spiel geben.");
+		}
+	}
+	// Statische Methoden
+	public static int getKartenId() {
+		return kartenId;
+	}
 
+	public static void setKartenId() {
+		kartenId++;
+	}
+	
+	// Getter und Setter (Kann es auch keine geben)
+	
+	// Overrides
+	@Override
+	public abstract String toString();
+	
+	// Public Methoden
+	
+	// Private Methoden
+	
+	
+
+	
+	
 }

Domain/Karten/Magierkarte.java

@@ -7,5 +7,56 @@ written on: 05 / 10 / 2023 at: 23:41
 package Domain.Karten;
 
 public class Magierkarte extends Karte {
+	
+	// Statische Konstanten
+	private static String TRUMPF_NAME = "Zauberer";
+	
+	// Statische Attribute
+	private static int mkAnzahl = 1; // mk = magierkarte
+	
+	// Attribute der Objekte
+	private String name;
+	
+	// Konstruktoren
+	public Magierkarte() {
+		super();
+		if (getMkAnzahl() <= 4) {
+			setName(TRUMPF_NAME);
+			setMkAnzahl();
+		}
+		else {
+			throw new RuntimeException("Es darf nur 4 Zaubererkarten im Spiel geben.");
+		}
+		
+	}
 
+	// Statischen Methoden
+	
+	// Getter und Setter
+
+	public int getMkAnzahl() {
+		return mkAnzahl;
+	}
+
+	public void setMkAnzahl() {
+		mkAnzahl++;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	// Overrides
+	@Override
+	public String toString() {
+		return this.name;
+	}
+		
+	// public Methoden
+	
+	// private Methoden
 }

Domain/Karten/Narrenkarte.java

@@ -8,4 +8,46 @@ package Domain.Karten;
 
 public class Narrenkarte extends Karte {
 
+	// Statische Konstanten
+	private final static String KARTE_NAME = "Narr";
+	// Statische Attribute
+	private static int nkAnzahl = 1;
+	// Attribute der Objekte
+	private String name;
+	// Konstruktoren
+	public Narrenkarte() {
+		super();
+		if (getNkAnzahl() <= 4) {
+			setName(KARTE_NAME);
+			setNkAnzahl();
+		}
+		else {
+			throw new RuntimeException("Es darf nur 4 Narrenkarten im Spiel geben.");
+		}
+	}
+	// Statische Methoden
+	
+	// Getter und Setter
+	private void setName(String name) {
+		this.name = name;
+	}
+	public String getName() {
+		return this.name;
+	}
+	
+	private void setNkAnzahl() {
+		nkAnzahl++;
+	}
+	public int getNkAnzahl() {
+		return nkAnzahl;
+	}
+	// Overrides
+	@Override
+	public String toString() {
+		return this.name;
+	}
+	// Public Methoden
+	
+	// Private Methoden
+	
 }

Domain/Karten/Zahlenkarte.java

@@ -6,6 +6,97 @@ written on: 05 / 10 / 2023 at: 23:30
 */
 package Domain.Karten;
 
+import Domain.Enums.Kartenfarbe;
+
 public class Zahlenkarte extends Karte {
 
+	// Statische Konstanten
+	private final static String NAME = "Charakterkarte";
+	// Statische Attribute
+	private static int menschID = 1;
+	private static int elfID = 1;
+	private static int rieseID = 1;
+	private static int zwergID = 1;
+	// Attribute der Objekte
+	private int kartenwert;
+	private Kartenfarbe charakter;
+	private String name;
+	// Konstruktoren
+	
+	public Zahlenkarte(Kartenfarbe farbe) {
+		super();
+		if (farbe == Kartenfarbe.MENSCH && menschID <=13) {
+			setNeueMenschKarte(farbe);
+		}
+		else if (farbe == Kartenfarbe.ELF && elfID <= 13) {
+			setNeueElfKarte(farbe);
+		}
+		else if (farbe == Kartenfarbe.RIESE && rieseID <= 13) {
+			setNeueRieseKarte(farbe);
+		}
+		else if (farbe == Kartenfarbe.ZWERG && zwergID <= 13) {
+			setNeueZwergKarte(farbe);
+		}
+		else {
+			throw new RuntimeException("Es darf von jedem Charakter nur 13 Karten im Spiel geben.");
+		}
+	}
+	// Statische Methoden
+	
+	// Getter und Setter
+	public int getKartenwert() {
+		return kartenwert;
+	}
+
+	public void setKartenwert(int kartenwert) {
+		this.kartenwert = kartenwert;
+	}
+
+	public Kartenfarbe getCharakter() {
+		return charakter;
+	}
+
+	public void setCharakter(Kartenfarbe charakter) {
+		this.charakter = charakter;
+	}
+	
+	public void setName() {
+		this.name = NAME;
+	}
+	// Overrides
+	@Override
+	public String toString() {
+		return this.name + " " + this.charakter + " " + this.kartenwert;
+	}
+	// Public Methoden
+	
+	// Private Methoden
+	private void setNeueMenschKarte(Kartenfarbe farbe) {
+		setCharakter(farbe);
+		setKartenwert(menschID);
+		setName();
+		menschID++;
+	}
+
+	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++;
+	}
+
 }

Domain/Kartenstapel.java

@@ -6,6 +6,155 @@ 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).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);
+		}
+	}
+
+	/**
+	 * 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() {
+		// Todo: Nur für den Trumpf
+		Karte austeilen = null;
+		if (kartengemischt.get(kartenzählen) != null && kartenzählen <= 60) {
+			
+			austeilen = kartengemischt.get(kartenzählen);
+			kartengemischt.remove(kartenzählen);
+			kartenzählen++;
+			
+		} 
+		else if (kartenzählen > 60) {
+			throw new RuntimeException("Es können nicht mehr als 60 Karten ausgeteilt werden.");
+		}
+		else {
+			throw new RuntimeException("Es ist ein Fehler in 'Kartenzählen' aufgetaucht.");
+		}
+
+		return austeilen;
+	}
+	
+	/**
+	 * 
+	 */
+	// Private Methoden
+
 }

Domain/Spieler.java

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

Facade/Spiel.java

@@ -6,6 +6,53 @@ written on: 05 / 10 / 2023 at: 23:25
 */
 package Facade;
 
+import Domain.Spieler;
+
 public class Spiel {
 
+	// Statische Konstanten
+	
+	// Statische Attribute
+	private static int runde = 0;
+	
+	// Attribute der Objekte
+	private Spieler spielerAmZug;
+	private boolean istGestartet = false;
+	private boolean istBeendet = true;
+	// Konstruktoren
+	public Spiel() {
+		setRunde();
+		setIstGestartet(true);
+		setIstBeendet(false);
+	}
+	// Statische Methoden
+	public static int getRunde() {
+		return runde;
+	}
+	// Getter und Setter
+	public void setIstGestartet(boolean wert) {
+		this.istGestartet = wert;
+	}
+	public boolean getIstGestartet() {
+		return this.istGestartet;
+	}
+	public void setIstBeendet(boolean wert) {
+		this.istBeendet = wert;
+	}
+	public boolean getIstBeendet() {
+		return istBeendet;
+	}
+	public Spieler getSpielerAmZug() {
+		return spielerAmZug;
+	}
+	// Overrides
+	
+	// Public Methoden
+	
+	// Private Methoden
+	private void setRunde() {
+		runde++;
+	}
+	
+
 }

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
+		
+		
+	}
+
+}

main/Main.java

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