feat(Blackjack):

umwandeln in neues Projekt

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/BlackJack.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="21" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/BlackJack.iml" filepath="$PROJECT_DIR$/.idea/BlackJack.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CommitMessageInspectionProfile">
+    <profile version="1.0">
+      <inspection_tool class="CommitFormat" enabled="true" level="WARNING" enabled_by_default="true" />
+      <inspection_tool class="CommitNamingConvention" enabled="true" level="WARNING" enabled_by_default="true" />
+    </profile>
+  </component>
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

src/main/java/de/deversmann/BlackJackSpiel.java

@@ -0,0 +1,48 @@
+package de.deversmann;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BlackJackSpiel {
+    private final Kartenstapel stapel;
+    private final List<Karte> hand;
+
+    public BlackJackSpiel(Kartenstapel stapel) {
+        this.stapel = stapel; // Verwendet den übergebenen Kartenstapel
+        hand = new ArrayList<>();
+        // Zieht die ersten zwei Karten für die Hand des Spielers
+        hand.add(stapel.zieheKarte());
+        hand.add(stapel.zieheKarte());
+    }
+
+
+    public void zieheWeitereKarte() {
+        if (getPunkte() < 21) {
+            hand.add(stapel.zieheKarte());
+        }
+    }
+
+    public int getPunkte() {
+        int punkte = 0;
+        int assAnzahl = 0;
+
+        for (Karte karte : hand) {
+            punkte += karte.getPunkte();
+            if ("Ass".equals(karte.wert())) {
+                assAnzahl++;
+            }
+        }
+
+        while (punkte > 21 && assAnzahl > 0) {
+            punkte -= 10; // Ass von 11 auf 1 Punkt reduzieren
+            assAnzahl--;
+        }
+
+        return punkte;
+    }
+
+    public List<Karte> getHand() {
+        return hand;
+    }
+}
+

src/main/java/de/deversmann/BlackJackUI.java

@@ -0,0 +1,59 @@
+package de.deversmann;
+
+import java.util.Scanner;
+
+public class BlackJackUI {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // Initialisiert den Kartenstapel einmal für alle Spiele
+        Kartenstapel stapel = new Kartenstapel();
+
+        while (true) {
+            // Prüft, ob genügend Karten für ein neues Spiel vorhanden sind
+            if (stapel.getVerbleibendeKarten() < 4) { // Geht davon aus, dass mindestens 4 Karten für ein Spiel benötigt werden
+                System.out.println("Nicht genügend Karten im Stapel für ein weiteres Spiel. Spiel beendet.");
+                break;
+            }
+
+            BlackJackSpiel spiel = new BlackJackSpiel(stapel); // Verwendet den existierenden Stapel für das neue Spiel
+            System.out.println("Neues Spiel gestartet. Viel Glück!");
+
+            while (true) {
+                System.out.println("Aktuelle Hand: " + spiel.getHand() + ". Aktuelle Punkte: " + spiel.getPunkte());
+
+                if (spiel.getPunkte() >= 21) {
+                    break;
+                }
+
+                System.out.print("Möchten Sie eine weitere Karte ziehen? (j/n): ");
+                String eingabe = scanner.nextLine();
+
+                if ("j".equalsIgnoreCase(eingabe)) {
+                    spiel.zieheWeitereKarte();
+                } else if ("n".equalsIgnoreCase(eingabe)) {
+                    break;
+                } else {
+                    System.out.println("Ungültige Eingabe. Bitte antworten Sie mit 'j' für ja oder 'n' für nein.");
+                }
+            }
+
+            System.out.println("Spielende. Ihre finale Hand: " + spiel.getHand() + ". Ihre Punkte: " + spiel.getPunkte());
+            if (spiel.getPunkte() > 21) {
+                System.out.println("Sie haben verloren. Mehr als 21 Punkte.");
+            } else if (spiel.getPunkte() == 21) {
+                System.out.println("Glückwunsch, Blackjack!");
+            } else {
+                System.out.println("Spiel beendet. Vielen Dank fürs Spielen.");
+            }
+
+            System.out.print("Möchten Sie noch eine Runde spielen? (j/n): ");
+            String erneutSpielen = scanner.nextLine();
+            if (!"j".equalsIgnoreCase(erneutSpielen)) {
+                break; // Beendet die Schleife und das Programm
+            }
+        }
+
+        System.out.println("Danke fürs Spielen. Auf Wiedersehen!");
+        scanner.close();
+    }
+}

src/main/java/de/deversmann/Karte.java

@@ -0,0 +1,23 @@
+package de.deversmann;
+
+public record Karte(String farbe, String wert) {
+
+    public int getPunkte() {
+        switch (wert) {
+            case "Ass" -> {
+                return 11; // Standardwert, Anpassung an die Hand erfolgt später
+            }
+            case "Bube", "Dame", "König" -> {
+                return 10;
+            }
+            default -> {
+                return Integer.parseInt(wert);
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return wert + " " + farbe;
+    }
+}

src/main/java/de/deversmann/Kartenstapel.java

@@ -0,0 +1,32 @@
+package de.deversmann;
+
+import java.util.Collections;
+import java.util.Stack;
+
+public class Kartenstapel {
+    private final Stack<Karte> stapel;
+
+    public Kartenstapel() {
+        stapel = new Stack<>();
+        String[] farben = {"Kreuz", "Pik", "Herz", "Karo"};
+        String[] werte = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Bube", "Dame", "König", "Ass"};
+
+        for (String farbe : farben) {
+            for (String wert : werte) {
+                stapel.push(new Karte(farbe, wert));
+            }
+        }
+
+        Collections.shuffle(stapel);
+    }
+
+    public Karte zieheKarte() {
+        if (stapel.isEmpty()) {
+            throw new RuntimeException("Alle Karten wurden bereits gezogen.");
+        }
+        return stapel.pop();
+    }
+    public int getVerbleibendeKarten() {
+        return stapel.size();
+    }
+}

src/test/java/BlackJackSpielTest.java

@@ -0,0 +1,87 @@
+import de.deversmann.BlackJackSpiel;
+import de.deversmann.Karte;
+import de.deversmann.Kartenstapel;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.when;
+
+class BlackJackSpielTest {
+
+    @Mock
+    private Kartenstapel mockStapel;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testGetHandGibtKorrekteHandZurueck() {
+        // Konfigurieren des Mocks, um spezifische Karten zurückzugeben
+        when(mockStapel.zieheKarte())
+                .thenReturn(new Karte("Herz", "10"))
+                .thenReturn(new Karte("Karo", "Ass"));
+
+        // Initialisieren des Spiels mit dem gemockten Kartenstapel
+        BlackJackSpiel spiel = new BlackJackSpiel(mockStapel);
+
+        // Überprüfen, ob die Hand des Spielers die erwarteten Karten enthält
+        assertEquals(2, spiel.getHand().size());
+        assertEquals("Herz", spiel.getHand().get(0).farbe());
+        assertEquals("10", spiel.getHand().get(0).wert());
+        assertEquals("Karo", spiel.getHand().get(1).farbe());
+        assertEquals("Ass", spiel.getHand().get(1).wert());
+    }
+    @Test
+    void testGetHandGibtKorrekteHandMit3KartenZurueck() {
+        // Konfigurieren des Mocks, um spezifische Karten zurückzugeben
+        when(mockStapel.zieheKarte())
+                .thenReturn(new Karte("Herz", "9"))
+                .thenReturn(new Karte("Karo", "Ass"))
+                .thenReturn(new Karte("Pik", "Ass"));
+
+        // Initialisieren des Spiels mit dem gemockten Kartenstapel
+        BlackJackSpiel spiel = new BlackJackSpiel(mockStapel);
+        spiel.zieheWeitereKarte();
+
+        // Überprüfen, ob die Hand des Spielers die erwarteten Karten enthält
+        assertEquals(3, spiel.getHand().size());
+        assertEquals("Herz", spiel.getHand().get(0).farbe());
+        assertEquals("9", spiel.getHand().get(0).wert());
+        assertEquals("Karo", spiel.getHand().get(1).farbe());
+        assertEquals("Ass", spiel.getHand().get(1).wert());
+        assertEquals("Pik", spiel.getHand().get(2).farbe());
+        assertEquals("Ass", spiel.getHand().get(2).wert());
+        assertEquals(21, spiel.getPunkte());
+    }
+
+    @Test
+    void testBlackjackMitZweiKarten() {
+        when(mockStapel.zieheKarte()).thenReturn(new Karte("Herz", "Ass"), new Karte("Pik", "König"));
+        BlackJackSpiel spiel = new BlackJackSpiel(mockStapel);
+        assertEquals(21, spiel.getPunkte());
+    }
+
+    @Test
+    void testUeber21MitMehrerenKarten() {
+        when(mockStapel.zieheKarte())
+                .thenReturn(new Karte("Herz", "10"), new Karte("Pik", "8"), new Karte("Karo", "4"));
+        BlackJackSpiel spiel = new BlackJackSpiel(mockStapel);
+        spiel.zieheWeitereKarte(); // Zieht die dritte Karte
+        assertTrue(spiel.getPunkte() > 21);
+    }
+
+    @Test
+    void testAssWertAnpassung() {
+        when(mockStapel.zieheKarte())
+                .thenReturn(new Karte("Herz", "Ass"), new Karte("Pik", "9"), new Karte("Karo", "Ass"));
+        BlackJackSpiel spiel = new BlackJackSpiel(mockStapel);
+        spiel.zieheWeitereKarte(); // Zieht die dritte Karte
+        assertEquals(21, spiel.getPunkte());
+    }
+}

src/test/java/KarteTest.java

@@ -0,0 +1,46 @@
+import de.deversmann.Karte;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class KarteTest {
+
+    @Test
+    void karteErstellenUndWertePruefen() {
+        Karte karte = new Karte("Herz", "10");
+        assertEquals("Herz", karte.farbe());
+        assertEquals("10", karte.wert());
+    }
+
+    @Test
+    void punkteFuerZahlenkarten() {
+        Karte zwei = new Karte("Karo", "2");
+        assertEquals(2, zwei.getPunkte());
+
+        Karte zehn = new Karte("Pik", "10");
+        assertEquals(10, zehn.getPunkte());
+    }
+
+    @Test
+    void punkteFuerBildkarten() {
+        Karte bube = new Karte("Kreuz", "Bube");
+        assertEquals(10, bube.getPunkte());
+
+        Karte dame = new Karte("Herz", "Dame");
+        assertEquals(10, dame.getPunkte());
+    }
+
+    @Test
+    void punkteFuerAss() {
+        Karte ass = new Karte("Pik", "Ass");
+        assertEquals(11, ass.getPunkte());
+    }
+
+    @Test
+    public void testToString() {
+        Karte karte = new Karte("Herz", "Ass");
+
+        String erwarteterString = "Ass Herz";
+        assertEquals(erwarteterString, karte.toString());
+    }
+}

src/test/java/KartenstapelTest.java

@@ -0,0 +1,33 @@
+import de.deversmann.Karte;
+import de.deversmann.Kartenstapel;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class KartenstapelTest {
+
+    @Test
+    void stapelErstellenUndKarteZiehen() {
+        Kartenstapel stapel = new Kartenstapel();
+        Karte karte = stapel.zieheKarte();
+        assertNotNull(karte); // Einfacher Test, um sicherzustellen, dass eine Karte gezogen wird
+    }
+
+    @Test
+    void alleKartenZiehen() {
+        Kartenstapel stapel = new Kartenstapel();
+        for (int i = 0; i < 52; i++) { // Zieht alle 52 Karten
+            assertNotNull(stapel.zieheKarte());
+        }
+
+        // Versucht, eine 53. Karte zu ziehen, was eine RuntimeException auslösen sollte
+        assertThrows(RuntimeException.class, stapel::zieheKarte);
+    }
+
+    @Test
+    void verbleibendeKarten() {
+        Kartenstapel stapel = new Kartenstapel();
+        stapel.zieheKarte(); // Zieht eine Karte
+        assertEquals(51, stapel.getVerbleibendeKarten()); // Erwartet 51 verbleibende Karten
+    }
+}