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)