windgeschworen/scripts/ui/card_deck.gd
danny 1b34931d6e CR 27: Poker wird echtes Texas Hold'em
Die CR-17-Variante — eine Setzrunde, je fuenf Karten, kein Aufdecken —
fuehlte sich nicht wie Poker an. Ersetzt durch Heads-up Hold'em: zwei
verdeckte Hole Cards je Seite, die fuenf Gemeinschaftskarten decken sich als
eigene Reihe zwischen den Haenden in drei Schritten auf (Flop, Turn, River),
vier Setzrunden mit Checken, Mitgehen, Erhoehen und Aussteigen. Kleiner und
grosser Blind wechseln pro Hand; der Small Blind handelt Pre-Flop zuerst und
schuldet dort die Blind-Differenz. Fixed Limit mit maximal zwei Erhoehungen
pro Strasse, damit der Pott lesbar bleibt.

CardDeck.evaluate_best_of bewertet die beste 5-aus-N-Kombination ueber einen
allgemeinen Kombinationszaehler — am River 21 Kombinationen; die
Gegner-Einschaetzung ruft am Flop und Turn auch mit fuenf oder sechs Karten
an, der naive Lass-zwei-weg-Ansatz waere am Turn falsch gewesen.

Der Gegner spielt eine Hand konsistent: ob er blufft, wuerfelt er einmal pro
Hand, nicht pro Entscheidung; seine Einschaetzung waechst mit jeder
aufgedeckten Strasse aus der echten Teilbewertung, skill mischt Wahrheit und
Rauschen. Pre-Flop zaehlt eine Hole-Card-Heuristik.

Spieltisch-Anbindung (Einsatz, Sitzordnung, Ridocs Dealer-Regel),
card_view-Platzhalter und das Messerspiel bleiben unveraendert.

Verifiziert mit dev_cr27_probe (16/16, darunter eine komplett
durchgespielte Partie mit Aufdecken bis zum River und Dealer-Wechsel ueber
alle Haende) und einem Boot-Check ueber sieben Szenen; Sonde vor dem Commit
geloescht.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-21 20:33:48 +02:00

214 lines
6.5 KiB
GDScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

class_name CardDeck
extends RefCounted
## Kartenblatt und Blattbewertung fürs Poker (CR 17).
##
## Lädt Farben und Werte aus data/minigames/cards.json, mischt ein volles
## Blatt und bewertet fünf Karten nach den üblichen Poker-Rängen. Bewusst
## ohne Godot-Knoten: Die Anzeige macht card_view.gd, hier liegt nur die
## Rechnung — dadurch kann eine Sonde das Blatt direkt prüfen.
##
## Eine Karte ist ein Dictionary { rank, suit, value, label, symbol,
## is_red }. Ein Blatt ist ein Array aus fünf solchen Karten.
const CARDS_PATH := "res://data/minigames/cards.json"
const HAND_HIGH_CARD := 0
const HAND_PAIR := 1
const HAND_TWO_PAIR := 2
const HAND_TRIPS := 3
const HAND_STRAIGHT := 4
const HAND_FLUSH := 5
const HAND_FULL_HOUSE := 6
const HAND_QUADS := 7
const HAND_STRAIGHT_FLUSH := 8
var suits: Array = []
var ranks: Array = []
var hand_names: Array = []
var texture_dir := ""
var texture_pattern := ""
var _draw_pile: Array = []
## Lädt die Blatt-Daten; liefert false, wenn die Datei fehlt oder kaputt ist.
func load_data() -> bool:
var file := FileAccess.open(CARDS_PATH, FileAccess.READ)
if file == null:
push_error("Kartendaten nicht lesbar: %s" % CARDS_PATH)
return false
var parsed: Variant = JSON.parse_string(file.get_as_text())
file.close()
if not (parsed is Dictionary) or not (parsed.get("suits") is Array):
push_error("Kartendaten sind ungültig: %s" % CARDS_PATH)
return false
suits = parsed["suits"]
ranks = parsed["ranks"]
hand_names = parsed.get("hand_names", [])
texture_dir = str(parsed.get("texture_dir", ""))
texture_pattern = str(parsed.get("texture_pattern", ""))
return true
## Baut ein volles, gemischtes Blatt aus allen Farb-Wert-Kombinationen.
func shuffle() -> void:
_draw_pile.clear()
for suit in suits:
for rank in ranks:
_draw_pile.append({
"rank": str(rank.get("id", "")),
"suit": str(suit.get("id", "")),
"value": int(rank.get("value", 0)),
"label": str(rank.get("label", "?")),
"symbol": str(suit.get("symbol", "?")),
"is_red": bool(suit.get("is_red", false)),
})
_draw_pile.shuffle()
## Zieht count Karten vom Stapel.
func draw(count: int) -> Array:
var hand: Array = []
for i in count:
if _draw_pile.is_empty():
break
hand.append(_draw_pile.pop_back())
return hand
## Anzahl der Karten, die noch im Stapel liegen.
func remaining() -> int:
return _draw_pile.size()
## Der Dateipfad zur Grafik einer Karte — existiert er nicht, zeichnet die
## Kartenansicht einen Platzhalter.
func texture_path(card: Dictionary) -> String:
if texture_dir.is_empty() or texture_pattern.is_empty():
return ""
var file_name := texture_pattern.replace("{rank}", str(card.get("rank", ""))).replace("{suit}", str(card.get("suit", "")))
return texture_dir + file_name
## Bewertet fünf Karten. Liefert { category, ranks, name }: category ist
## einer der HAND_-Werte, ranks die absteigend nach Gruppengröße und Wert
## sortierten Kartenwerte für den Stichentscheid.
func evaluate(hand: Array) -> Dictionary:
var values: Array[int] = []
var suit_counts := {}
var value_counts := {}
for card in hand:
var value := int(card.get("value", 0))
values.append(value)
value_counts[value] = int(value_counts.get(value, 0)) + 1
var suit := str(card.get("suit", ""))
suit_counts[suit] = int(suit_counts.get(suit, 0)) + 1
values.sort()
values.reverse()
var is_flush := false
for suit in suit_counts:
if int(suit_counts[suit]) == hand.size():
is_flush = true
var is_straight := _is_straight(values)
var groups: Array = []
for value in value_counts:
groups.append({ "value": int(value), "count": int(value_counts[value]) })
groups.sort_custom(func(a: Dictionary, b: Dictionary) -> bool:
if a["count"] == b["count"]:
return a["value"] > b["value"]
return a["count"] > b["count"])
var ordered: Array[int] = []
for group in groups:
for i in int(group["count"]):
ordered.append(int(group["value"]))
var category := HAND_HIGH_CARD
var top_count := 0 if groups.is_empty() else int(groups[0]["count"])
var second_count := 0 if groups.size() < 2 else int(groups[1]["count"])
if is_straight and is_flush:
category = HAND_STRAIGHT_FLUSH
elif top_count == 4:
category = HAND_QUADS
elif top_count == 3 and second_count == 2:
category = HAND_FULL_HOUSE
elif is_flush:
category = HAND_FLUSH
elif is_straight:
category = HAND_STRAIGHT
elif top_count == 3:
category = HAND_TRIPS
elif top_count == 2 and second_count == 2:
category = HAND_TWO_PAIR
elif top_count == 2:
category = HAND_PAIR
var name := "?"
if category < hand_names.size():
name = str(hand_names[category])
return { "category": category, "ranks": ordered, "name": name }
## Bewertet die beste 5-Karten-Hand aus einem größeren Satz (Texas
## Hold'em, CR 27: am River 2 eigene + 5 Gemeinschaftskarten = 21
## Kombinationen; die Gegner-Einschätzung ruft auch mit 5 oder 6 Karten
## an). Liefert dasselbe Format wie evaluate().
func evaluate_best_of(cards: Array) -> Dictionary:
if cards.size() <= 5:
return evaluate(cards)
var best := {}
for combo in _five_card_combos(cards):
var rating := evaluate(combo)
if best.is_empty() or compare(rating, best) > 0:
best = rating
return best
## Alle 5-Karten-Teilmengen eines Kartensatzes.
func _five_card_combos(cards: Array) -> Array:
var combos: Array = []
var indices: Array[int] = [0, 1, 2, 3, 4]
while true:
var hand: Array = []
for i in indices:
hand.append(cards[i])
combos.append(hand)
var slot := 4
while slot >= 0 and indices[slot] == cards.size() - 5 + slot:
slot -= 1
if slot < 0:
break
indices[slot] += 1
for j in range(slot + 1, 5):
indices[j] = indices[j - 1] + 1
return combos
## Vergleicht zwei bewertete Blätter: 1 wenn das erste gewinnt, −1 wenn das
## zweite gewinnt, 0 bei Gleichstand.
func compare(first: Dictionary, second: Dictionary) -> int:
var a := int(first.get("category", 0))
var b := int(second.get("category", 0))
if a != b:
return 1 if a > b else -1
var ranks_a: Array = first.get("ranks", [])
var ranks_b: Array = second.get("ranks", [])
for i in mini(ranks_a.size(), ranks_b.size()):
if int(ranks_a[i]) != int(ranks_b[i]):
return 1 if int(ranks_a[i]) > int(ranks_b[i]) else -1
return 0
## Prüft auf fünf aufeinanderfolgende Werte; das Ass zählt zusätzlich tief
## (Ass-2-3-4-5, die „kleine Straße").
func _is_straight(sorted_values: Array[int]) -> bool:
var unique: Array[int] = []
for value in sorted_values:
if not value in unique:
unique.append(value)
if unique.size() != 5:
return false
if unique[0] - unique[4] == 4:
return true
return unique == [14, 5, 4, 3, 2]