# Blackjack Implementierungs-Roadmap

Dies ist eine schrittweise Anleitung zur Implementierung des Blackjack-Spiels basierend auf dem bereitgestellten Klassendiagramm. Der Fokus liegt auf der **inkrementellen Entwicklung** und dem Testen jeder Klasse, bevor mit der nächsten begonnen wird.

---

## Phase 1: Die Grundlagen – Karten und Stapel

Das Ziel dieser Phase ist die Erstellung des statischen Materials: der Karten und des Decks.

### 1. Card (Karte)

| Fokus | Hinweise |
| :--- | :--- |
| **Attribute** | `rank` (z.B. 'A', 'K', '5'), `suit` (z.B. 'Herz', 'Pik'), `value` (initialer Blackjack-Wert). |
| **Logik** | Definiere die Wertzuordnung: 2-10 sind ihr Nennwert, Bube/Dame/König sind **10**, Ass ist initial **11**. |
| **Methode** | Implementiere `__str__` für eine klare Ausgabe (z.B. "Ass der Pik"). |

### 2. Deck (Kartenstapel)

| Fokus | Hinweise |
| :--- | :--- |
| **Initialisierung** | Erzeuge im Konstruktor **alle 52** `Card`-Objekte (vier Farben $\times$ 13 Ränge) und speichere sie in der internen Liste `cards`. |
| **`shuffle()`** | Verwende eine geeignete Bibliotheksfunktion (z.B. `random.shuffle` in Python) zum Mischen der `cards`-Liste. |
| **`deal_card()`** | Entferne die oberste Karte aus der Liste (z.B. `pop()`) und gib sie zurück. Behandele den Fall, dass das Deck leer ist (optional). |

---

## Phase 2: Hände und Wertberechnung

Diese Phase implementiert die Kernlogik von Blackjack: die Verwaltung einer Hand und die flexible Wertberechnung.

### 3. Hand (Spielerhand)

| Fokus | Hinweise |
| :--- | :--- |
| **`add_card(card)`** | Füge die Karte zur Liste hinzu. Aktualisiere **sofort** den Handwert und zähle die Anzahl der Asse (`aces`). |
| **`calculate_value()`** | Gib die einfache Summe der Werte aller Karten zurück. |
| **`adjust_for_ace()`** | Die **wichtigste Logik** von Blackjack: Rufe diese Methode nach jeder Kartenaufnahme auf. **Schleife:** Solange der Gesamtwert (`value`) **über 21** ist **UND** Asse vorhanden sind (`aces > 0`), **reduziere** den Wert um 10 und verringere `aces` um 1. |

### 4. Player / Dealer (Basisstruktur)

| Fokus | Hinweise |
| :--- | :--- |
| **`Player`** | Definiere die Basisattribute (`name`, `chips`, `hand`). |
| **`hit(deck)`** | Ruft `deck.deal_card()` auf und übergibt die Karte an `self.hand.add_card()`. |
| **`Dealer`** | Erbt von `Player`. Benötigt zunächst nur die Vererbung. |

---

## Phase 3: Spielsteuerung und Rundenablauf

Hier wird das Spielbrett aufgestellt und die grundlegende Interaktion ermöglicht.

### 5. Game-Setup

| Fokus | Hinweise |
| :--- | :--- |
| **Konstruktor** | Initialisiere die zentralen Komponenten: `Deck` (mischen nicht vergessen!), `Player` und `Dealer`. |
| **`show_cards()`** | Zeige die Karten des Spielers komplett an. Für den Dealer zeige nur die **erste** Karte an, bis die Spielzüge beendet sind. |

### 6. Geber-Logik und Spielzüge

| Fokus | Hinweise |
| :--- | :--- |
| **`Dealer.play(deck)`** | Implementiere die feste Geber-Regel: Der Dealer muss `hit()` aufrufen, solange sein Handwert **kleiner als 17** ist. |
| **Spieler-Zug** | Implementiere eine Schleife in `play_round()`, die den Spieler nach "Hit" oder "Stand" fragt, bis er steht oder überkauft ("Bust", $>21$). |

---

## Phase 4: Abschluss, Vergleich und Finanzen

Der letzte Schritt kümmert sich um die Auszahlung und den wiederholten Spielbetrieb.

### 7. Ergebnis und Chip-Management

| Fokus | Hinweise |
| :--- | :--- |
| **`compare_hands()`** | Diese Methode wird aufgerufen, nachdem sowohl der Spieler als auch der Dealer ihre Züge abgeschlossen haben. |
| **Vergleich** | Berücksichtige alle Fälle in dieser Reihenfolge: **Blackjack** (21 auf 2 Karten), **Bust** (wer hat > 21?), **höherer Wert** gewinnt, **Push** (Gleichstand). |
| **Chips** | Passe die `chips` des Spielers basierend auf dem Ergebnis von `compare_hands()` an (z.B. $\times 1.5$ für Blackjack, $\times 1$ für normalen Gewinn, $0$ für Push, $-\text{Einsatz}$ für Verlust). |

### 8. Spiel-Loop

| Fokus | Hinweise |
| :--- | :--- |
| **Hauptfunktion** | Erstelle die Hauptroutine, die wiederholt **Einsatz erfragt**, `deck.shuffle()` aufruft und `play_round()` startet, bis der Spieler keine Chips mehr hat oder beenden möchte. |