Poker lief bisher ueber Menue-Optionen und fuehlte sich nicht wie Poker an. Jetzt liegt ein echtes Blatt auf dem Tisch. CardDeck mischt aus data/minigames/cards.json ein volles 52er-Blatt und bewertet fuenf Karten nach den echten Poker-Raengen — hohe Karte bis Straight Flush, inklusive kleiner Strasse mit tiefem Ass und Stichentscheid bei gleicher Kategorie. Bewusst ohne Godot-Knoten, damit die Rechnung direkt pruefbar ist. Echte Setzrunden: beide bekommen fuenf Karten, die des Gegners liegen verdeckt. Der Spieler eroeffnet, der Gegner antwortet mit eigener Entscheidung — er schaetzt sein Blatt nach seinem skill ein und erhoeht mit schwachem Blatt nur, wenn er blufft. Danach Showdown mit benanntem Rang. card_view zeigt die PNG aus assets/ui/cards/, sobald sie da ist, und zeichnet sonst eine Platzhalter-Karte aus Rechteck, Wert und Farbzeichen. Ein README im Zielordner dokumentiert die Benennung. Der Bau hat nicht auf die Assets gewartet, und mit ihnen wird es nur huebscher, nicht anders. table_seating fuehrt den gewaehlten Gegner sichtbar zum runden Tisch und setzt ihn hin; danach gehen alle zurueck. Dealer-Regel wie gefordert: spielt jemand anderes, dealt Ridoc; spielt Ridoc selbst, dealt er sich selbst und belegt nur den Gegnerplatz. Die Sitzordnung greift vor beiden Spielen, also auch vorm Messerspiel. Beim Bauen gefunden: die erste Fassung sammelte die finished-Signale mehrerer Tweens und wartete sie nacheinander ab — war der erste schon durch, brach das await ab. Die Sonde meldete trotzdem gruen, weil die Endpositionen stimmten; erst das Fehlerprotokoll zeigte es. Jetzt laeuft je Phase ein einziger paralleler Tween. Verifiziert mit dev_cr17_probe (41/41) und einem Boot-Check ueber zehn Szenen, Log ohne Laufzeitfehler; Sonde vor dem Commit geloescht. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
179 lines
5.5 KiB
GDScript
179 lines
5.5 KiB
GDScript
class_name CardDeck
|
||
extends RefCounted
|
||
## Kartenblatt und Blattbewertung fürs Poker (CR 17).
|
||
##
|
||
## Lädt Farben und Werte aus data/minigames/cards.json, mischt ein volles
|
||
## Blatt und bewertet fünf Karten nach den üblichen Poker-Rängen. Bewusst
|
||
## ohne Godot-Knoten: Die Anzeige macht card_view.gd, hier liegt nur die
|
||
## Rechnung — dadurch kann eine Sonde das Blatt direkt prüfen.
|
||
##
|
||
## Eine Karte ist ein Dictionary { rank, suit, value, label, symbol,
|
||
## is_red }. Ein Blatt ist ein Array aus fünf solchen Karten.
|
||
|
||
const CARDS_PATH := "res://data/minigames/cards.json"
|
||
|
||
const HAND_HIGH_CARD := 0
|
||
const HAND_PAIR := 1
|
||
const HAND_TWO_PAIR := 2
|
||
const HAND_TRIPS := 3
|
||
const HAND_STRAIGHT := 4
|
||
const HAND_FLUSH := 5
|
||
const HAND_FULL_HOUSE := 6
|
||
const HAND_QUADS := 7
|
||
const HAND_STRAIGHT_FLUSH := 8
|
||
|
||
var suits: Array = []
|
||
var ranks: Array = []
|
||
var hand_names: Array = []
|
||
var texture_dir := ""
|
||
var texture_pattern := ""
|
||
|
||
var _draw_pile: Array = []
|
||
|
||
|
||
## Lädt die Blatt-Daten; liefert false, wenn die Datei fehlt oder kaputt ist.
|
||
func load_data() -> bool:
|
||
var file := FileAccess.open(CARDS_PATH, FileAccess.READ)
|
||
if file == null:
|
||
push_error("Kartendaten nicht lesbar: %s" % CARDS_PATH)
|
||
return false
|
||
var parsed: Variant = JSON.parse_string(file.get_as_text())
|
||
file.close()
|
||
if not (parsed is Dictionary) or not (parsed.get("suits") is Array):
|
||
push_error("Kartendaten sind ungültig: %s" % CARDS_PATH)
|
||
return false
|
||
suits = parsed["suits"]
|
||
ranks = parsed["ranks"]
|
||
hand_names = parsed.get("hand_names", [])
|
||
texture_dir = str(parsed.get("texture_dir", ""))
|
||
texture_pattern = str(parsed.get("texture_pattern", ""))
|
||
return true
|
||
|
||
|
||
## Baut ein volles, gemischtes Blatt aus allen Farb-Wert-Kombinationen.
|
||
func shuffle() -> void:
|
||
_draw_pile.clear()
|
||
for suit in suits:
|
||
for rank in ranks:
|
||
_draw_pile.append({
|
||
"rank": str(rank.get("id", "")),
|
||
"suit": str(suit.get("id", "")),
|
||
"value": int(rank.get("value", 0)),
|
||
"label": str(rank.get("label", "?")),
|
||
"symbol": str(suit.get("symbol", "?")),
|
||
"is_red": bool(suit.get("is_red", false)),
|
||
})
|
||
_draw_pile.shuffle()
|
||
|
||
|
||
## Zieht count Karten vom Stapel.
|
||
func draw(count: int) -> Array:
|
||
var hand: Array = []
|
||
for i in count:
|
||
if _draw_pile.is_empty():
|
||
break
|
||
hand.append(_draw_pile.pop_back())
|
||
return hand
|
||
|
||
|
||
## Anzahl der Karten, die noch im Stapel liegen.
|
||
func remaining() -> int:
|
||
return _draw_pile.size()
|
||
|
||
|
||
## Der Dateipfad zur Grafik einer Karte — existiert er nicht, zeichnet die
|
||
## Kartenansicht einen Platzhalter.
|
||
func texture_path(card: Dictionary) -> String:
|
||
if texture_dir.is_empty() or texture_pattern.is_empty():
|
||
return ""
|
||
var file_name := texture_pattern.replace("{rank}", str(card.get("rank", ""))).replace("{suit}", str(card.get("suit", "")))
|
||
return texture_dir + file_name
|
||
|
||
|
||
## Bewertet fünf Karten. Liefert { category, ranks, name }: category ist
|
||
## einer der HAND_-Werte, ranks die absteigend nach Gruppengröße und Wert
|
||
## sortierten Kartenwerte für den Stichentscheid.
|
||
func evaluate(hand: Array) -> Dictionary:
|
||
var values: Array[int] = []
|
||
var suit_counts := {}
|
||
var value_counts := {}
|
||
for card in hand:
|
||
var value := int(card.get("value", 0))
|
||
values.append(value)
|
||
value_counts[value] = int(value_counts.get(value, 0)) + 1
|
||
var suit := str(card.get("suit", ""))
|
||
suit_counts[suit] = int(suit_counts.get(suit, 0)) + 1
|
||
values.sort()
|
||
values.reverse()
|
||
|
||
var is_flush := false
|
||
for suit in suit_counts:
|
||
if int(suit_counts[suit]) == hand.size():
|
||
is_flush = true
|
||
var is_straight := _is_straight(values)
|
||
|
||
var groups: Array = []
|
||
for value in value_counts:
|
||
groups.append({ "value": int(value), "count": int(value_counts[value]) })
|
||
groups.sort_custom(func(a: Dictionary, b: Dictionary) -> bool:
|
||
if a["count"] == b["count"]:
|
||
return a["value"] > b["value"]
|
||
return a["count"] > b["count"])
|
||
var ordered: Array[int] = []
|
||
for group in groups:
|
||
for i in int(group["count"]):
|
||
ordered.append(int(group["value"]))
|
||
|
||
var category := HAND_HIGH_CARD
|
||
var top_count := 0 if groups.is_empty() else int(groups[0]["count"])
|
||
var second_count := 0 if groups.size() < 2 else int(groups[1]["count"])
|
||
if is_straight and is_flush:
|
||
category = HAND_STRAIGHT_FLUSH
|
||
elif top_count == 4:
|
||
category = HAND_QUADS
|
||
elif top_count == 3 and second_count == 2:
|
||
category = HAND_FULL_HOUSE
|
||
elif is_flush:
|
||
category = HAND_FLUSH
|
||
elif is_straight:
|
||
category = HAND_STRAIGHT
|
||
elif top_count == 3:
|
||
category = HAND_TRIPS
|
||
elif top_count == 2 and second_count == 2:
|
||
category = HAND_TWO_PAIR
|
||
elif top_count == 2:
|
||
category = HAND_PAIR
|
||
|
||
var name := "?"
|
||
if category < hand_names.size():
|
||
name = str(hand_names[category])
|
||
return { "category": category, "ranks": ordered, "name": name }
|
||
|
||
|
||
## 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:
|
||
var a := int(first.get("category", 0))
|
||
var b := int(second.get("category", 0))
|
||
if a != b:
|
||
return 1 if a > b else -1
|
||
var ranks_a: Array = first.get("ranks", [])
|
||
var ranks_b: Array = second.get("ranks", [])
|
||
for i in mini(ranks_a.size(), ranks_b.size()):
|
||
if int(ranks_a[i]) != int(ranks_b[i]):
|
||
return 1 if int(ranks_a[i]) > int(ranks_b[i]) else -1
|
||
return 0
|
||
|
||
|
||
## Prüft auf fünf aufeinanderfolgende Werte; das Ass zählt zusätzlich tief
|
||
## (Ass-2-3-4-5, die „kleine Straße").
|
||
func _is_straight(sorted_values: Array[int]) -> bool:
|
||
var unique: Array[int] = []
|
||
for value in sorted_values:
|
||
if not value in unique:
|
||
unique.append(value)
|
||
if unique.size() != 5:
|
||
return false
|
||
if unique[0] - unique[4] == 4:
|
||
return true
|
||
return unique == [14, 5, 4, 3, 2]
|