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 } ## 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: 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]