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:
parent
c929ab8484
commit
1b34931d6e
7 changed files with 350 additions and 161 deletions
|
|
@ -15,11 +15,11 @@
|
|||
"injury_line": "Die Klinge erwischt den Daumenballen. Nicht tief. Tief genug, dass die Hand morgen langsamer ist."
|
||||
},
|
||||
"poker": {
|
||||
"title": "Poker",
|
||||
"rules_line": "Fünf Karten, keine Tauschrunde, ein Einsatz. Es geht nicht um die Karten. Es ging nie um die Karten.",
|
||||
"rounds": 4,
|
||||
"ante": 1,
|
||||
"raise_multiplier": 2
|
||||
"title": "Hold'em",
|
||||
"rules_line": "Zwei Karten verdeckt, fünf für alle, vier Setzrunden. Die Blinds wandern. Wer bis zum River lügt, muss es auch zeigen können.",
|
||||
"hands": 4,
|
||||
"small_blind": 1,
|
||||
"big_blind": 2
|
||||
}
|
||||
},
|
||||
"opponents": [
|
||||
|
|
|
|||
|
|
@ -41,44 +41,6 @@
|
|||
(Treiber/Vulkan-Stall beim ersten Betreten einer Szene, Fokus-Verlust im
|
||||
Editor-Vollbild) lassen sich erst mit einem echten Log belegen.
|
||||
|
||||
## 27. Poker wird echtes Texas Hold'em (ersetzt CR-17-Umsetzung)
|
||||
> Autor-Entscheidung (2026-07-21): Die CR-17-Umsetzung (`poker_game.gd`) ist
|
||||
> eine einzige Setzrunde mit je 5 verdeckten Karten ohne Kartentausch — fühlt
|
||||
> sich nicht wie Poker an. **Ersetzt durch echtes Texas Hold'em.** Meine
|
||||
> ursprüngliche CR 17 hat die Variante nie festgelegt — das war eine
|
||||
> Spezifikations-Lücke, keine falsche Umsetzung.
|
||||
- **Regeln:**
|
||||
- Jeder Spieler bekommt **2 verdeckte Handkarten** (Hole Cards).
|
||||
- **Gemeinschaftskarten** werden in drei Schritten aufgedeckt: **Flop** (3
|
||||
Karten auf einmal), **Turn** (1 Karte), **River** (1 Karte).
|
||||
- **Vier Setzrunden**, je eine nach: Hole Cards (Pre-Flop), Flop, Turn,
|
||||
River. Optionen: Checken (wenn niemand gesetzt hat), Mitgehen, Erhöhen,
|
||||
Aussteigen.
|
||||
- **Blinds statt reinem Ante:** Kleiner/großer Blind wechseln pro Runde
|
||||
zwischen Spieler und Gegner (Heads-up-Poker, 1 gegen 1).
|
||||
- **Showdown:** beste 5-Karten-Hand aus den 7 verfügbaren (2 eigene + 5
|
||||
Gemeinschaftskarten).
|
||||
- **Technische Delta-Notiz (aus Code-Lektüre):** `CardDeck.evaluate()` nimmt
|
||||
aktuell **genau 5 Karten** an (Flush-/Straight-Prüfung geht von exakt 5
|
||||
Werten aus). Für Hold'em wird eine **Best-of-7-Bewertung** gebraucht (die
|
||||
beste 5-Karten-Kombination aus 7 testen, 21 Kombinationen) — das ist eine
|
||||
echte Erweiterung, kein Aufruf-Detail.
|
||||
- **Gegner-KI:** `_decide()` muss über **mehrere Straßen** hinweg konsistent
|
||||
bluffen/einschätzen (aktuell nur einmalig), inkl. steigendem Pot über die
|
||||
Runden. `skill`/`bluff_rate` pro Gegner bleiben als Konzept erhalten.
|
||||
- **UI:** Gemeinschaftskarten-Reihe zwischen den beiden Händen, die sich nach
|
||||
Flop/Turn/River sukzessive füllt — genau das „Kartenaufdecken", das der
|
||||
Autor vermisst hat. Eigene Hole Cards bleiben offen, Gegner-Hole-Cards
|
||||
verdeckt bis zum Showdown.
|
||||
- **Betrifft:** `poker_game.gd` (weitgehende Neufassung), `card_deck.gd`
|
||||
(Best-of-7-Bewertung), `card_view.gd` (Gemeinschaftskarten-Layout),
|
||||
`data/minigames/table_games.json` (Runden-Konfiguration anpassen).
|
||||
Platzhalter-Karten-Prinzip aus CR 17 bleibt (Bau wartet nicht auf PNGs).
|
||||
- **Akzeptanz:** Eine Partie läuft über Pre-Flop/Flop/Turn/River mit je einer
|
||||
Setzrunde; Gemeinschaftskarten decken sich sichtbar auf; Showdown wählt
|
||||
korrekt die beste 5-aus-7-Kombination beider Seiten; Blinds wechseln pro
|
||||
Runde. Messerspiel bleibt unverändert (nutzt kein Kartenblatt).
|
||||
|
||||
## 24. Primitiven-Austausch in den echten Szenen (Folge-Schritt aus CR 23)
|
||||
> Aufgemacht am 2026-07-21, nachdem CR 23 die Pipeline verifiziert hat. Die
|
||||
> Assets liegen sortiert und importiert unter `assets/models/`, die
|
||||
|
|
|
|||
|
|
@ -3,6 +3,51 @@
|
|||
> Abgearbeitete Change Requests aus CHANGEREQUESTS.md, mit Datum und
|
||||
> Anmerkung, was geändert wurde.
|
||||
|
||||
## 2026-07-21 — CR 27: Poker wird echtes Texas Hold'em
|
||||
|
||||
**Request:** CHANGEREQUESTS §27 — die CR-17-Umsetzung (eine Setzrunde,
|
||||
je fünf Karten, kein Aufdecken) fühlte sich nicht wie Poker an.
|
||||
Autoren-Entscheidung: echtes Heads-up Texas Hold'em, ersetzt die
|
||||
CR-17-Spielmechanik komplett.
|
||||
|
||||
**Regeln wie gefordert:** 2 verdeckte Hole Cards je Seite; die fünf
|
||||
Gemeinschaftskarten decken sich in drei Schritten auf (Flop 3, Turn 1,
|
||||
River 1) und liegen sichtbar als eigene Reihe zwischen den Händen;
|
||||
**vier Setzrunden** (Pre-Flop/Flop/Turn/River) mit 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 schuldet dort die Blind-Differenz
|
||||
(Heads-up-Regel); der **Showdown wählt die beste 5-Karten-Hand aus 7**.
|
||||
Fixed Limit mit maximal zwei Erhöhungen pro Straße, damit der Pott
|
||||
lesbar bleibt.
|
||||
|
||||
**Technik:** `CardDeck.evaluate_best_of()` bewertet die beste
|
||||
5-aus-N-Kombination über einen allgemeinen Kombinationszähler — am
|
||||
River 21 Kombinationen, und die Gegner-Einschätzung ruft am Flop/Turn
|
||||
auch mit 5 oder 6 Karten an (der naive „lass zwei weg"-Ansatz wäre am
|
||||
Turn falsch gewesen). `poker_game.gd` weitgehend neu; die
|
||||
Spieltisch-Anbindung (Einsatz multipliziert den Saldo, Sitzordnung,
|
||||
Ridocs Dealer-Regel) blieb unverändert, ebenso das Messerspiel.
|
||||
|
||||
**Gegner-KI über die Straßen:** Ob der Gegner blufft, würfelt er
|
||||
**einmal pro Hand** (bluff_rate), nicht pro Entscheidung; seine
|
||||
Einschätzung wächst mit jeder aufgedeckten Straße aus der echten
|
||||
Teilbewertung seiner Karten, `skill` mischt Wahrheit und Rauschen.
|
||||
Pre-Flop zählt eine Hole-Card-Heuristik (Paar/hohe Karte).
|
||||
|
||||
**Platzhalter-Prinzip aus CR 17 bleibt:** `card_view.gd` unverändert —
|
||||
liegen die PNGs unter `assets/ui/cards/`, wird es hübscher, nicht anders.
|
||||
|
||||
**Verifikation:** Sonde `dev_cr27_probe` 16/16 — Best-of-7 findet den
|
||||
Flush hinter dem Ass-Paar, Best-of-6 das Full House am Turn, 21
|
||||
Kombinationen aus 7 Karten; Blinds statt Ante in der Konfiguration;
|
||||
eine komplett durchgespielte Partie (2 offene eigene, 2 verdeckte
|
||||
Gegner-Karten, 5 verdeckte Gemeinschaftskarten, Blinds im Pott,
|
||||
Aufdecken bis zum River, Dealer-Wechsel über alle Hände, Saldo am
|
||||
Ende); nur Aussteigen verliert höchstens die Blinds; Messerspiel
|
||||
kartenfrei und Spieltisch-Anbindung unverändert. Boot-Check über sieben
|
||||
Szenen fehlerfrei. Sonde vor dem Commit gelöscht.
|
||||
|
||||
## 2026-07-21 — CR 26: Stimmen-Schreibpass fertiggestellt (die restlichen 31 Dateien)
|
||||
|
||||
**Request:** CHANGEREQUESTS §26 — CR 19+22 hatte nur 11 Dateien wirklich
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ Greifen erst nach Dreschen + erstem Flug; brauchen die CR-6-Basis.
|
|||
| 22 | Journal/Lexicon-Texte | Politur | erledigt (2026-07-21) |
|
||||
| 25 | Absturz bei Türwechseln (Bug) | Politur | **in Beobachtung (2026-07-21)** — nicht reproduzierbar (175+ Wechsel sauber); Härtung + Log-Forensik drin, wartet auf nächsten Vorfall mit Log |
|
||||
| 26 | Schreibpass-Rest (31 Dateien) | Politur | **erledigt (2026-07-21)** — alle 31 geprüft, 15 umgeschrieben nach STIMMEN.md; Fingerabdruck strukturgleich, 17 erledigte Dateien unangetastet |
|
||||
| 27 | Poker → Texas Hold'em | Politur | **erledigt (2026-07-21)** — Hole Cards, Flop/Turn/River, vier Setzrunden, wechselnde Blinds, Best-of-7-Showdown |
|
||||
| 23 | Asset-Import-Grundausstattung (Quaternius) | Politur | **erledigt (2026-07-21)** — 296 Modelle sortiert unter `assets/models/`, Rig-Kompatibilität in `scenes/test/asset_pipeline_test.tscn` verifiziert |
|
||||
| 24 | Primitiven-Austausch in den echten Szenen | Politur | offen — Folge-Schritt aus CR 23, Pipeline steht |
|
||||
| 25 | Türwechsel-Absturz (Bug) | Politur | offen — Verdacht in `zone_trigger.gd`, Repro + Stack-Trace nötig |
|
||||
|
|
|
|||
|
|
@ -30,10 +30,10 @@ anchor_left = 0.5
|
|||
anchor_top = 0.5
|
||||
anchor_right = 0.5
|
||||
anchor_bottom = 0.5
|
||||
offset_left = -380.0
|
||||
offset_top = -260.0
|
||||
offset_right = 380.0
|
||||
offset_bottom = 260.0
|
||||
offset_left = -400.0
|
||||
offset_top = -318.0
|
||||
offset_right = 400.0
|
||||
offset_bottom = 318.0
|
||||
grow_horizontal = 2
|
||||
grow_vertical = 2
|
||||
theme_override_styles/panel = SubResource("StyleBoxFlat_panel")
|
||||
|
|
@ -50,7 +50,7 @@ theme_override_constants/separation = 8
|
|||
[node name="TitleLabel" type="Label" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_colors/font_color = Color(0.94, 0.94, 0.88, 1)
|
||||
theme_override_font_sizes/font_size = 19
|
||||
text = "Poker"
|
||||
text = "Hold'em"
|
||||
|
||||
[node name="Header" type="HBoxContainer" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_constants/separation = 16
|
||||
|
|
@ -59,12 +59,17 @@ theme_override_constants/separation = 16
|
|||
size_flags_horizontal = 3
|
||||
theme_override_colors/font_color = Color(0.72, 0.76, 0.68, 1)
|
||||
theme_override_font_sizes/font_size = 14
|
||||
text = "Runde 1 / 4"
|
||||
text = "Hand 1 / 4"
|
||||
|
||||
[node name="BlindLabel" type="Label" parent="Root/Panel/Margin/Content/Header"]
|
||||
theme_override_colors/font_color = Color(0.68, 0.74, 0.78, 1)
|
||||
theme_override_font_sizes/font_size = 14
|
||||
text = "Du: kleiner Blind"
|
||||
|
||||
[node name="PotLabel" type="Label" parent="Root/Panel/Margin/Content/Header"]
|
||||
theme_override_colors/font_color = Color(0.86, 0.8, 0.55, 1)
|
||||
theme_override_font_sizes/font_size = 14
|
||||
text = "Pott: 2"
|
||||
text = "Pott: 3"
|
||||
|
||||
[node name="TheirRow" type="VBoxContainer" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_constants/separation = 4
|
||||
|
|
@ -78,11 +83,17 @@ text = "Gegner"
|
|||
custom_minimum_size = Vector2(0, 92)
|
||||
theme_override_constants/separation = 6
|
||||
|
||||
[node name="TellLabel" type="Label" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_colors/font_color = Color(0.78, 0.74, 0.58, 1)
|
||||
theme_override_font_sizes/font_size = 15
|
||||
text = ""
|
||||
autowrap_mode = 3
|
||||
[node name="CommunityRow" type="VBoxContainer" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_constants/separation = 4
|
||||
|
||||
[node name="CommunityLabel" type="Label" parent="Root/Panel/Margin/Content/CommunityRow"]
|
||||
theme_override_colors/font_color = Color(0.7, 0.78, 0.7, 1)
|
||||
theme_override_font_sizes/font_size = 14
|
||||
text = "Tisch"
|
||||
|
||||
[node name="CommunityCards" type="HBoxContainer" parent="Root/Panel/Margin/Content/CommunityRow"]
|
||||
custom_minimum_size = Vector2(0, 92)
|
||||
theme_override_constants/separation = 6
|
||||
|
||||
[node name="OwnRow" type="VBoxContainer" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_constants/separation = 4
|
||||
|
|
@ -94,14 +105,14 @@ theme_override_constants/separation = 6
|
|||
[node name="OwnLabel" type="Label" parent="Root/Panel/Margin/Content/OwnRow"]
|
||||
theme_override_colors/font_color = Color(0.9, 0.9, 0.85, 1)
|
||||
theme_override_font_sizes/font_size = 16
|
||||
text = "Dein Blatt"
|
||||
text = "Deine Hand"
|
||||
|
||||
[node name="Actions" type="HBoxContainer" parent="Root/Panel/Margin/Content"]
|
||||
theme_override_constants/separation = 8
|
||||
|
||||
[node name="CallButton" type="Button" parent="Root/Panel/Margin/Content/Actions"]
|
||||
[node name="CheckCallButton" type="Button" parent="Root/Panel/Margin/Content/Actions"]
|
||||
size_flags_horizontal = 3
|
||||
text = "Mitgehen"
|
||||
text = "Checken"
|
||||
|
||||
[node name="RaiseButton" type="Button" parent="Root/Panel/Margin/Content/Actions"]
|
||||
size_flags_horizontal = 3
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue