From a5ebd0c26dab4fd2ad796252ced0e85b83c7e744 Mon Sep 17 00:00:00 2001 From: Kai Sellmann <2210892@stud.hs-mannheim.de> Date: Tue, 24 Oct 2023 11:38:55 +0200 Subject: [PATCH] update --- Domain/Karten/Karte.java | 2 + Domain/Karten/Test/KarteTest.java | 14 --- Domain/Karten/Zahlenkarte.java | 17 +++- Domain/Kartenstapel.java | 144 ++++++++++++++++++++++++++++++ Facade/Spiel.java | 5 ++ Infrastructure/Persistenz.java | 1 + Test/Domain/KartenstapelTest.java | 60 +++++++++++++ 7 files changed, 228 insertions(+), 15 deletions(-) delete mode 100644 Domain/Karten/Test/KarteTest.java create mode 100644 Test/Domain/KartenstapelTest.java diff --git a/Domain/Karten/Karte.java b/Domain/Karten/Karte.java index 1911a1a..371c2b4 100644 --- a/Domain/Karten/Karte.java +++ b/Domain/Karten/Karte.java @@ -26,5 +26,7 @@ public abstract class Karte { public static void setKartenId() { kartenId++; } + + public abstract String getName(); } diff --git a/Domain/Karten/Test/KarteTest.java b/Domain/Karten/Test/KarteTest.java deleted file mode 100644 index e7490d0..0000000 --- a/Domain/Karten/Test/KarteTest.java +++ /dev/null @@ -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() { - - } - -} diff --git a/Domain/Karten/Zahlenkarte.java b/Domain/Karten/Zahlenkarte.java index 578715e..291acaf 100644 --- a/Domain/Karten/Zahlenkarte.java +++ b/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; + } } diff --git a/Domain/Kartenstapel.java b/Domain/Kartenstapel.java index 4621d97..7e825fa 100644 --- a/Domain/Kartenstapel.java +++ b/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 kartensortiert = new HashMap<>(); + + private HashMap 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 getKartenstapelSortiert() { + return kartensortiert.values(); + } + + public Collection 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 getStatusGemischt() { + HashMap 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 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 + } diff --git a/Facade/Spiel.java b/Facade/Spiel.java index 615cbc1..618b843 100644 --- a/Facade/Spiel.java +++ b/Facade/Spiel.java @@ -8,4 +8,9 @@ package Facade; public class Spiel { + public static int getRunde() { + // TODO Auto-generated method stub + return 0; + } + } diff --git a/Infrastructure/Persistenz.java b/Infrastructure/Persistenz.java index ca38033..d523f79 100644 --- a/Infrastructure/Persistenz.java +++ b/Infrastructure/Persistenz.java @@ -8,4 +8,5 @@ package Infrastructure; public class Persistenz { + } diff --git a/Test/Domain/KartenstapelTest.java b/Test/Domain/KartenstapelTest.java new file mode 100644 index 0000000..b3849f8 --- /dev/null +++ b/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 + + + } + +}