windgeschworen/scripts/ui/poker_game.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

332 lines
12 KiB
GDScript

extends CanvasLayer
## Texas Hold'em am runden Tisch, Heads-up (CR 27 — ersetzt die
## Eine-Setzrunde-Variante aus CR 17).
##
## 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 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. 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 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_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 _result_label: Label = $Root/Panel/Margin/Content/ResultLabel
@onready var _actions: HBoxContainer = $Root/Panel/Margin/Content/Actions
@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
## Startet verborgen, lädt das Blatt und verbindet die Aktionen.
func _ready() -> void:
visible = false
_deck.load_data()
_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 über mehrere Hände (Coroutine) und liefert den
## Marken-Saldo des Spielers.
func play(config: Dictionary, opponent: Dictionary) -> int:
_title_label.text = "Hold'em — gegen %s" % str(opponent.get("name", "?"))
_their_label.text = str(opponent.get("name", "?"))
visible = true
var hands := int(config.get("hands", config.get("rounds", 4)))
var balance := 0
_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 Spieler-Aktion aus (öffentlich für Sonden).
func act(action: int) -> void:
_act(action)
## Aktuell aufgedeckte Gemeinschaftskarten (für Sonden).
func revealed_community() -> int:
return _revealed
## Der laufende Pott (für Sonden).
func current_pot() -> int:
return _pot
## 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 Hand: Blinds, vier Straßen, Showdown.
func _play_hand(config: Dictionary, opponent: Dictionary) -> int:
_deck.shuffle()
_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))
_blind_label.text = "Du: kleiner Blind" if _is_player_dealer else "Du: großer Blind"
_result_label.text = ""
_show_hand(_own_cards, _own_hole, true)
_show_hand(_their_cards, _their_hole, false)
_show_community()
_update_own_rating()
_update_pot()
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
_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 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 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 -own_paid
_result_label.text = "Gleichstand — der Pott wird geteilt."
await _pause()
return 0
## 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)))
if is_bluffing:
judged = maxf(judged, 0.7)
if outstanding > 0 and judged < 0.18:
return ACTION_FOLD
if judged > 0.55 and raises < MAX_RAISES_PER_STREET:
return ACTION_RAISE
return ACTION_CALL if outstanding > 0 else ACTION_CHECK
## 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)
## Ü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()
for card in hand:
var view := Control.new()
view.set_script(CARD_VIEW_SCRIPT)
row.add_child(view)
if is_face_up:
view.show_card(card, _deck)
else:
view.show_back(_deck)
## 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(RESULT_SECONDS).timeout
## Meldet die Aktion genau einmal.
func _act(action: int) -> void:
if not _is_open:
return
_is_open = false
acted.emit(action)