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>
214 lines
6.5 KiB
GDScript
214 lines
6.5 KiB
GDScript
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]
|