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>
This commit is contained in:
danny 2026-07-21 20:33:48 +02:00
parent c929ab8484
commit 1b34931d6e
7 changed files with 350 additions and 161 deletions

View file

@ -150,6 +150,41 @@ func evaluate(hand: Array) -> Dictionary:
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:

View file

@ -1,45 +1,61 @@
extends CanvasLayer
## Poker am runden Tisch — mit sichtbaren Karten (CR 17, ersetzt die
## Menü-Variante aus CR 13).
## Texas Hold'em am runden Tisch, Heads-up (CR 27 — ersetzt die
## Eine-Setzrunde-Variante aus CR 17).
##
## Klassische Ansicht: Beide bekommen fünf Karten, die des Gegners liegen
## bis zum Showdown verdeckt. Gespielt wird über echte Setzrunden — der
## Spieler eröffnet (mitgehen, erhöhen, aussteigen), der Gegner antwortet
## darauf mit eigener Entscheidung, dann werden die Blätter aufgedeckt und
## verglichen (CardDeck rechnet die Ränge).
## Echte Hold'em-Struktur: Beide bekommen 2 verdeckte Handkarten, die
## fünf Gemeinschaftskarten decken sich in drei Schritten auf — Flop
## (drei auf einmal), Turn, River — mit je einer Setzrunde nach Hole
## Cards, Flop, Turn und River. Optionen: Checken (wenn nichts im Raum
## steht), Mitgehen, Erhöhen, Aussteigen. Kleiner und großer Blind
## wechseln pro Hand zwischen Spieler und Gegner; der Small Blind
## handelt Pre-Flop zuerst und nach dem Flop als Zweiter
## (Heads-up-Regel). Der Showdown wählt die beste 5-Karten-Hand aus den
## 7 verfügbaren (CardDeck.evaluate_best_of).
##
## Der Gegner spielt wie er ist: `skill` bestimmt, wie gut er sein Blatt
## einschätzt, `bluff_rate`, wie oft er mit schwachem Blatt trotzdem
## erhöht. Imogen blufft am meisten, Wren fast nie.
## Der Gegner spielt eine ganze Hand konsistent: Ob er blufft, würfelt
## er einmal pro Hand (bluff_rate), nicht pro Zeile; seine Einschätzung
## wächst mit jeder aufgedeckten Straße und hängt an seinem skill.
## Setzlimit: eine Erhöhung pro Seite und Straße (Fixed Limit), damit
## der Pott lesbar bleibt.
##
## Die Karten-Grafiken liefert der Autor unter assets/ui/cards/ nach; bis
## dahin zeichnet card_view.gd Platzhalter. Am Ablauf ändert das nichts.
## Die Karten-Grafiken liefert der Autor unter assets/ui/cards/ nach;
## bis dahin zeichnet card_view.gd Platzhalter. play() liefert wie
## bisher den Marken-Saldo der Partie an den Spieltisch.
signal acted(action: int)
const CARD_VIEW_SCRIPT := preload("res://scripts/ui/card_view.gd")
const HAND_SIZE := 5
const ACTION_CALL := 0
const ACTION_RAISE := 1
const ACTION_FOLD := 2
const REVEAL_SECONDS := 2.2
const HOLE_CARDS := 2
const COMMUNITY_CARDS := 5
const ACTION_CHECK := 0
const ACTION_CALL := 1
const ACTION_RAISE := 2
const ACTION_FOLD := 3
const REVEAL_SECONDS := 1.4
const RESULT_SECONDS := 2.4
const MAX_RAISES_PER_STREET := 2
var _deck := CardDeck.new()
var _is_open := false
var _own_hand: Array = []
var _their_hand: Array = []
var _own_hole: Array = []
var _their_hole: Array = []
var _community: Array = []
var _revealed := 0
var _pot := 0
var _is_player_dealer := true
@onready var _title_label: Label = $Root/Panel/Margin/Content/TitleLabel
@onready var _round_label: Label = $Root/Panel/Margin/Content/Header/RoundLabel
@onready var _pot_label: Label = $Root/Panel/Margin/Content/Header/PotLabel
@onready var _blind_label: Label = $Root/Panel/Margin/Content/Header/BlindLabel
@onready var _their_cards: HBoxContainer = $Root/Panel/Margin/Content/TheirRow/TheirCards
@onready var _their_label: Label = $Root/Panel/Margin/Content/TheirRow/TheirLabel
@onready var _community_cards: HBoxContainer = $Root/Panel/Margin/Content/CommunityRow/CommunityCards
@onready var _own_cards: HBoxContainer = $Root/Panel/Margin/Content/OwnRow/OwnCards
@onready var _own_label: Label = $Root/Panel/Margin/Content/OwnRow/OwnLabel
@onready var _tell_label: Label = $Root/Panel/Margin/Content/TellLabel
@onready var _result_label: Label = $Root/Panel/Margin/Content/ResultLabel
@onready var _actions: HBoxContainer = $Root/Panel/Margin/Content/Actions
@onready var _call_button: Button = $Root/Panel/Margin/Content/Actions/CallButton
@onready var _check_call_button: Button = $Root/Panel/Margin/Content/Actions/CheckCallButton
@onready var _raise_button: Button = $Root/Panel/Margin/Content/Actions/RaiseButton
@onready var _fold_button: Button = $Root/Panel/Margin/Content/Actions/FoldButton
@ -48,129 +64,234 @@ var _their_hand: Array = []
func _ready() -> void:
visible = false
_deck.load_data()
_call_button.pressed.connect(_act.bind(ACTION_CALL))
_check_call_button.pressed.connect(_on_check_call)
_raise_button.pressed.connect(_act.bind(ACTION_RAISE))
_fold_button.pressed.connect(_act.bind(ACTION_FOLD))
## Spielt die Partie (Coroutine) und liefert den Marken-Saldo.
## Spielt die Partie über mehrere Hände (Coroutine) und liefert den
## Marken-Saldo des Spielers.
func play(config: Dictionary, opponent: Dictionary) -> int:
_title_label.text = "%s — gegen %s" % [str(config.get("title", "Poker")), str(opponent.get("name", "?"))]
_title_label.text = "Hold'em — gegen %s" % str(opponent.get("name", "?"))
_their_label.text = str(opponent.get("name", "?"))
visible = true
var rounds := int(config.get("rounds", 4))
var ante := int(config.get("ante", 1))
var raise_multiplier := int(config.get("raise_multiplier", 2))
var hands := int(config.get("hands", config.get("rounds", 4)))
var balance := 0
for index in rounds:
balance += await _play_round(index, rounds, ante, raise_multiplier, opponent)
_is_player_dealer = randf() < 0.5
for index in hands:
_round_label.text = "Hand %d / %d" % [index + 1, hands]
balance += await _play_hand(config, opponent)
_is_player_dealer = not _is_player_dealer
visible = false
return balance
## Löst eine Aktion aus. Öffentlich, damit Sonden deterministisch spielen.
## Löst eine Spieler-Aktion aus (öffentlich für Sonden).
func act(action: int) -> void:
_act(action)
## Das eigene Blatt der laufenden Runde (für Sonden).
func get_own_hand() -> Array:
return _own_hand
## Aktuell aufgedeckte Gemeinschaftskarten (für Sonden).
func revealed_community() -> int:
return _revealed
## Das Blatt des Gegners (für Sonden).
func get_their_hand() -> Array:
return _their_hand
## Der laufende Pott (für Sonden).
func current_pot() -> int:
return _pot
## Das Kartenblatt dieser Partie (für Sonden).
## Hat der Spieler in dieser Hand den Dealer-Knopf? (für Sonden)
func is_player_dealer() -> bool:
return _is_player_dealer
## Die eigenen Handkarten (für Sonden).
func get_own_hole() -> Array:
return _own_hole
## Die Gegner-Handkarten (für Sonden).
func get_their_hole() -> Array:
return _their_hole
## Das Kartenblatt (für Sonden).
func get_deck() -> CardDeck:
return _deck
## Spielt eine Runde: austeilen, Setzrunde, Gegner-Antwort, Showdown.
func _play_round(index: int, rounds: int, ante: int, raise_multiplier: int, opponent: Dictionary) -> int:
## Spielt eine Hand: Blinds, vier Straßen, Showdown.
func _play_hand(config: Dictionary, opponent: Dictionary) -> int:
_deck.shuffle()
_own_hand = _deck.draw(HAND_SIZE)
_their_hand = _deck.draw(HAND_SIZE)
var own_rating := _deck.evaluate(_own_hand)
var their_rating := _deck.evaluate(_their_hand)
var pot := ante * 2
_own_hole = _deck.draw(HOLE_CARDS)
_their_hole = _deck.draw(HOLE_CARDS)
_community = _deck.draw(COMMUNITY_CARDS)
_revealed = 0
var small_blind := int(config.get("small_blind", 1))
var big_blind := int(config.get("big_blind", 2))
var own_paid := small_blind if _is_player_dealer else big_blind
var their_paid := big_blind if _is_player_dealer else small_blind
_pot = own_paid + their_paid
var is_bluffing := randf() < float(opponent.get("bluff_rate", 0.3))
_round_label.text = "Runde %d / %d" % [index + 1, rounds]
_pot_label.text = "Pott: %d" % pot
_blind_label.text = "Du: kleiner Blind" if _is_player_dealer else "Du: großer Blind"
_result_label.text = ""
_show_hand(_own_cards, _own_hand, true)
_show_hand(_their_cards, _their_hand, false)
_own_label.text = "Dein Blatt: %s" % str(own_rating.get("name", "?"))
_tell_label.text = _tell_for(their_rating, opponent)
_actions.visible = true
_is_open = true
_call_button.grab_focus.call_deferred()
var action: int = await acted
_actions.visible = false
_show_hand(_own_cards, _own_hole, true)
_show_hand(_their_cards, _their_hole, false)
_show_community()
_update_own_rating()
_update_pot()
if action == ACTION_FOLD:
_result_label.text = "Ausgestiegen. Der Ante bleibt liegen. −%d" % ante
await _pause()
return -ante
for street in 4:
if street > 0:
_revealed = 2 + street
_show_community()
_update_own_rating()
await get_tree().create_timer(REVEAL_SECONDS).timeout
var opening := big_blind - small_blind if street == 0 else 0
var outcome: Dictionary = await _betting_round(street, big_blind, opponent, is_bluffing, opening)
own_paid += int(outcome.get("own_added", 0))
their_paid += int(outcome.get("their_added", 0))
if outcome.get("folded_by", "") == "player":
_result_label.text = "Ausgestiegen. %s nimmt den Pott (%d)." % [str(opponent.get("name", "?")), _pot]
await _pause()
return -own_paid
if outcome.get("folded_by", "") == "opponent":
_show_hand(_their_cards, _their_hole, true)
_result_label.text = "%s wirft weg. Der Pott (%d) gehört dir." % [str(opponent.get("name", "?")), _pot]
await _pause()
return their_paid
var stake := ante
if action == ACTION_RAISE:
stake = ante * raise_multiplier
var their_action := _decide(their_rating, action, opponent)
if their_action == ACTION_FOLD:
_show_hand(_their_cards, _their_hand, true)
_result_label.text = "%s wirft weg. Der Pott gehört dir. +%d" % [str(opponent.get("name", "?")), stake]
await _pause()
return stake
if their_action == ACTION_RAISE:
stake *= raise_multiplier
pot = stake * 2
_pot_label.text = "Pott: %d" % pot
_show_hand(_their_cards, _their_hand, true)
_show_hand(_their_cards, _their_hole, true)
var own_rating := _deck.evaluate_best_of(_own_hole + _community)
var their_rating := _deck.evaluate_best_of(_their_hole + _community)
_their_label.text = "%s: %s" % [str(opponent.get("name", "?")), str(their_rating.get("name", "?"))]
var outcome := _deck.compare(own_rating, their_rating)
if outcome > 0:
_result_label.text = "%s schlägt %s. +%d" % [str(own_rating.get("name", "?")), str(their_rating.get("name", "?")), stake]
var comparison := _deck.compare(own_rating, their_rating)
if comparison > 0:
_result_label.text = "%s schlägt %s. Der Pott (%d) gehört dir." % [str(own_rating.get("name", "?")), str(their_rating.get("name", "?")), _pot]
await _pause()
return stake
if outcome < 0:
_result_label.text = "%s schlägt %s. −%d" % [str(their_rating.get("name", "?")), str(own_rating.get("name", "?")), stake]
return their_paid
if comparison < 0:
_result_label.text = "%s schlägt %s. Der Pott (%d) geht rüber." % [str(their_rating.get("name", "?")), str(own_rating.get("name", "?")), _pot]
await _pause()
return -stake
_result_label.text = "Gleichstand. Der Pott wird geteilt."
return -own_paid
_result_label.text = "Gleichstand — der Pott wird geteilt."
await _pause()
return 0
## Entscheidet die Antwort des Gegners: Er schätzt sein Blatt nach seinem
## skill ein und erhöht mit schwachem Blatt nur, wenn er blufft.
func _decide(their_rating: Dictionary, player_action: int, opponent: Dictionary) -> int:
var strength := float(their_rating.get("category", 0)) / float(CardDeck.HAND_STRAIGHT_FLUSH)
## Eine Setzrunde (Fixed Limit, maximal zwei Erhöhungen): liefert die
## Einzahlungen beider Seiten und wer ggf. weggeworfen hat. Heads-up
## handelt Pre-Flop der Small Blind (Dealer) zuerst und schuldet dort
## die Blind-Differenz (opening); nach dem Flop beginnt der andere.
func _betting_round(street: int, unit: int, opponent: Dictionary, is_bluffing: bool, opening := 0) -> Dictionary:
var player_first := _is_player_dealer if street == 0 else not _is_player_dealer
var own_added := 0
var their_added := 0
var outstanding := opening
var raises := 0
var is_player_turn := player_first
var checks_or_calls := 0
while checks_or_calls < 2:
var action: int
if is_player_turn:
action = await _ask_player(outstanding, unit, raises)
else:
action = _decide(street, outstanding, raises, opponent, is_bluffing)
match action:
ACTION_FOLD:
return { "own_added": own_added, "their_added": their_added,
"folded_by": "player" if is_player_turn else "opponent" }
ACTION_CHECK:
checks_or_calls += 1
ACTION_CALL:
if is_player_turn:
own_added += outstanding
else:
their_added += outstanding
_pot += outstanding
outstanding = 0
checks_or_calls += 1
ACTION_RAISE:
var to_put := outstanding + unit
if is_player_turn:
own_added += to_put
else:
their_added += to_put
_result_label.text = "%s erhöht um %d." % [str(opponent.get("name", "?")), unit]
_pot += to_put
outstanding = unit
raises += 1
checks_or_calls = 1
_update_pot()
is_player_turn = not is_player_turn
return { "own_added": own_added, "their_added": their_added, "folded_by": "" }
## Fragt den Spieler nach seiner Aktion; die Knöpfe passen sich der Lage
## an (Checken vs. Mitgehen, Erhöhen nur unter dem Limit).
func _ask_player(outstanding: int, unit: int, raises: int) -> int:
_check_call_button.text = "Checken" if outstanding == 0 else "Mitgehen (%d)" % outstanding
_raise_button.visible = raises < MAX_RAISES_PER_STREET
_raise_button.text = "Erhöhen (+%d)" % unit
_actions.visible = true
_is_open = true
_check_call_button.grab_focus.call_deferred()
var action: int = await acted
_actions.visible = false
return action
## Entscheidet den Gegner: Die Einschätzung seines Blatts wächst mit den
## aufgedeckten Straßen (skill mischt Wahrheit und Rauschen); ob er
## blufft, steht für die ganze Hand fest.
func _decide(street: int, outstanding: int, raises: int, opponent: Dictionary, is_bluffing: bool) -> int:
var strength := _their_strength(street)
var judged := lerpf(randf(), strength, float(opponent.get("skill", 0.5)))
var is_bluffing := randf() < float(opponent.get("bluff_rate", 0.3))
if judged < 0.12 and player_action == ACTION_RAISE and not is_bluffing:
if is_bluffing:
judged = maxf(judged, 0.7)
if outstanding > 0 and judged < 0.18:
return ACTION_FOLD
if judged > 0.45 or is_bluffing:
if judged > 0.55 and raises < MAX_RAISES_PER_STREET:
return ACTION_RAISE
return ACTION_CALL
return ACTION_CALL if outstanding > 0 else ACTION_CHECK
## Baut das Tell des Gegners: Es zeigt die Wahrheit über sein Blatt, außer
## er blufft gerade — dann zeigt es das Gegenteil.
func _tell_for(their_rating: Dictionary, opponent: Dictionary) -> String:
var is_strong := int(their_rating.get("category", 0)) >= CardDeck.HAND_PAIR
if randf() < float(opponent.get("bluff_rate", 0.3)):
is_strong = not is_strong
var name := str(opponent.get("name", "Dein Gegenüber"))
if is_strong:
return "%s sitzt still. Zu still." % name
return "%s zählt die eigenen Marken nach. Zum zweiten Mal." % name
## Die wahre Stärke der Gegnerhand auf der aktuellen Straße (0..1).
func _their_strength(street: int) -> float:
if street == 0:
var high := 0
for card in _their_hole:
high = maxi(high, int(card.get("value", 0)))
var is_pair: bool = _their_hole.size() == 2 and int(_their_hole[0].get("value", -1)) == int(_their_hole[1].get("value", -2))
return 0.85 if is_pair else float(high) / 20.0
var visible_cards: Array = _their_hole + _community.slice(0, _revealed)
var rating := _deck.evaluate_best_of(visible_cards)
return float(rating.get("category", 0)) / float(CardDeck.HAND_STRAIGHT_FLUSH)
## Legt ein Blatt in eine Reihe; is_face_up entscheidet über offen oder zu.
## Übersetzt den Checken/Mitgehen-Knopf in die passende Aktion.
func _on_check_call() -> void:
var is_call := _check_call_button.text.begins_with("Mitgehen")
_act(ACTION_CALL if is_call else ACTION_CHECK)
## Zeigt das eigene Blatt samt aktuellem Rang an.
func _update_own_rating() -> void:
if _revealed == 0:
_own_label.text = "Deine Hand"
return
var rating := _deck.evaluate_best_of(_own_hole + _community.slice(0, _revealed))
_own_label.text = "Deine Hand: %s" % str(rating.get("name", "?"))
## Schreibt den Pott in die Kopfzeile.
func _update_pot() -> void:
_pot_label.text = "Pott: %d" % _pot
## Legt ein Blatt in eine Reihe; is_face_up entscheidet über offen/zu.
func _show_hand(row: HBoxContainer, hand: Array, is_face_up: bool) -> void:
for child in row.get_children():
child.queue_free()
@ -184,9 +305,23 @@ func _show_hand(row: HBoxContainer, hand: Array, is_face_up: bool) -> void:
view.show_back(_deck)
## Lässt das Ergebnis kurz stehen, damit man die Blätter sieht.
## Zeigt die Gemeinschaftskarten: aufgedeckte offen, der Rest verdeckt.
func _show_community() -> void:
for child in _community_cards.get_children():
child.queue_free()
for i in COMMUNITY_CARDS:
var view := Control.new()
view.set_script(CARD_VIEW_SCRIPT)
_community_cards.add_child(view)
if i < _revealed:
view.show_card(_community[i], _deck)
else:
view.show_back(_deck)
## Lässt das Ergebnis kurz stehen.
func _pause() -> void:
await get_tree().create_timer(REVEAL_SECONDS).timeout
await get_tree().create_timer(RESULT_SECONDS).timeout
## Meldet die Aktion genau einmal.