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>
332 lines
12 KiB
GDScript
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)
|