diff --git a/assets/ui/cards/README.md b/assets/ui/cards/README.md new file mode 100644 index 0000000..ab68df5 --- /dev/null +++ b/assets/ui/cards/README.md @@ -0,0 +1,15 @@ +# assets/ui/cards/ + +Hier liegen die Karten-PNGs für das Poker am Spieltisch (CR 17). + +**Benennung** (aus `data/minigames/cards.json`, Schlüssel `texture_pattern`): +`{rank}_{suit}.png` — also z. B. `ass_herz.png`, `10_pik.png`, `dame_karo.png`. + +- `rank`: `2` … `10`, `bube`, `dame`, `koenig`, `ass` +- `suit`: `herz`, `karo`, `pik`, `kreuz` +- Rückseite: `ruecken.png` + +Empfohlenes Seitenverhältnis 64 × 92 (die Kartenansicht skaliert +seitenverhältnistreu). Solange eine Datei fehlt, zeichnet +`scripts/ui/card_view.gd` automatisch eine Platzhalter-Karte — das Spiel +ist in beiden Zuständen vollständig spielbar. diff --git a/data/minigames/cards.json b/data/minigames/cards.json new file mode 100644 index 0000000..2fb459e --- /dev/null +++ b/data/minigames/cards.json @@ -0,0 +1,38 @@ +{ + "design_note": "CR 17. Das Blatt ist daten-getrieben: Farben und Werte stehen hier, die Kartenansicht baut daraus ihre Anzeige. texture_dir + texture_pattern zeigen auf die PNGs, die der Autor nachliefert — der Dateiname entsteht aus dem Muster, z. B. dame_herz.png. Fehlt eine Datei, zeichnet card_view.gd eine Platzhalter-Karte (Rechteck mit Wert und Farbzeichen). Das Spiel ist in beiden Zuständen identisch spielbar; die PNGs machen es nur hübscher.", + "texture_dir": "res://assets/ui/cards/", + "texture_pattern": "{rank}_{suit}.png", + "back_texture": "ruecken.png", + "suits": [ + { "id": "herz", "name": "Herz", "symbol": "♥", "is_red": true }, + { "id": "karo", "name": "Karo", "symbol": "♦", "is_red": true }, + { "id": "pik", "name": "Pik", "symbol": "♠", "is_red": false }, + { "id": "kreuz", "name": "Kreuz", "symbol": "♣", "is_red": false } + ], + "ranks": [ + { "id": "2", "label": "2", "value": 2 }, + { "id": "3", "label": "3", "value": 3 }, + { "id": "4", "label": "4", "value": 4 }, + { "id": "5", "label": "5", "value": 5 }, + { "id": "6", "label": "6", "value": 6 }, + { "id": "7", "label": "7", "value": 7 }, + { "id": "8", "label": "8", "value": 8 }, + { "id": "9", "label": "9", "value": 9 }, + { "id": "10", "label": "10", "value": 10 }, + { "id": "bube", "label": "B", "value": 11 }, + { "id": "dame", "label": "D", "value": 12 }, + { "id": "koenig", "label": "K", "value": 13 }, + { "id": "ass", "label": "A", "value": 14 } + ], + "hand_names": [ + "Hohe Karte", + "Ein Paar", + "Zwei Paare", + "Drilling", + "Straße", + "Flush", + "Full House", + "Vierling", + "Straight Flush" + ] +} diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index 00db3db..60e11a5 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -11,30 +11,6 @@ > Findings des Autors beim Durchspielen von v1. **Priorität vor den Akt-2-CRs > weiter unten** — das ist Politur am fertigen v1-Umfang. -## 17. Poker mit echten Karten + Figuren am Tisch -> Delta gegen die CR-13-Umsetzung: Poker läuft aktuell rein über Menü-Optionen -> und fühlt sich dadurch nicht wie Poker an; die Gegner sind abstrakt statt -> anwesend. -- **Echte Karten als UI-Overlay** (entschieden): klassische Poker-Ansicht mit - sichtbaren Karten und echten Setzrunden statt reiner Text-Optionen. **Kein** - 3D-Kartenmodell. - - **Die Karten-Grafiken liefert der Autor** als PNGs unter `assets/ui/cards/` - (daten-getrieben referenzieren). **Greybox-First:** Bis die PNGs da sind, muss - das Spiel mit einfachen Platzhalter-Karten (Rechteck + Wert/Farbe als Text) - vollständig spielbar sein — der Bau wartet NICHT auf die Assets. -- **Figuren laufen an und setzen sich:** Wählt man einen Gegner, kommt die Figur - sichtbar zum Spieltisch der Aula gelaufen und nimmt Platz. -- **Dealer-Rollenlogik:** - - Gegner = **Imogen** (oder andere Figur) → **Ridoc übernimmt den Dealer**. - - Gegner = **Ridoc** → er dealt **selbst** und spielt zugleich. -- **Akzeptanz:** Poker wird mit sichtbaren Karten über echte Setzrunden gespielt; - der gewählte Gegner läuft an und sitzt am Tisch; die Dealer-Rolle ist nach obiger - Regel besetzt; mit Platzhalter-Karten voll spielbar, mit den PNGs identisch, nur - hübscher. -- **Betrifft:** `game_table.gd`, `data/minigames/table_games.json`, Aula-Szene. -- **Annahme (bitte widersprechen, falls falsch):** Das Anlaufen/Hinsetzen gilt für - den Spieltisch generell, also auch fürs **Messerspiel**. - ## 19. Stimmen-Schreibpass — Dialoge klingen „geschrieben", nicht gesprochen > Autor: Violet klingt nicht wie Violet, Imogen ist gegenüber Tyrveil zu > abgedroschen, **Xaden ist am schlimmsten**. diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 551c895..79d3397 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -3,6 +3,61 @@ > Abgearbeitete Change Requests aus CHANGEREQUESTS.md, mit Datum und > Anmerkung, was geändert wurde. +## 2026-07-21 — CR 17: Poker mit echten Karten + Figuren am Tisch + +**Request:** CHANGEREQUESTS §17 — Poker lief rein über Menü-Optionen und +fühlte sich nicht wie Poker an, die Gegner waren abstrakt statt anwesend. +Gefordert: sichtbare Karten mit echten Setzrunden, anlaufende Figuren, +Dealer-Rollenlogik, und volle Spielbarkeit mit Platzhalter-Karten. + +**Karten und Blattbewertung:** `data/minigames/cards.json` beschreibt +Farben, Werte, Blattnamen und das Namensmuster der PNGs. +`scripts/ui/card_deck.gd` (`class_name CardDeck`) mischt daraus ein +volles 52er-Blatt, teilt aus und **bewertet fünf Karten nach den echten +Poker-Rängen** — von der hohen Karte bis zum Straight Flush, inklusive +kleiner Straße mit tiefem Ass und Stichentscheid bei gleicher Kategorie. +Bewusst als RefCounted ohne Godot-Knoten, damit die Sonde die Rechnung +direkt prüfen kann. + +**Platzhalter statt Wartezeit:** `scripts/ui/card_view.gd` lädt die PNG +aus `assets/ui/cards/`, sobald sie da ist, und zeichnet sonst eine +Karte aus Rechteck, Wert und Farbzeichen (rot/schwarz). Beide Zustände +sind gleich groß und gleich bedienbar. Ein README im Zielordner +dokumentiert die Benennung (`ass_herz.png`, `10_pik.png`, `ruecken.png`) +— der Bau hat nicht auf die Assets gewartet. + +**Echte Setzrunden:** Beide bekommen fünf Karten, die des Gegners liegen +verdeckt. Der Spieler eröffnet (mitgehen, erhöhen, aussteigen), **der +Gegner antwortet mit eigener Entscheidung** — er schätzt sein Blatt nach +seinem `skill` ein und erhöht mit schwachem Blatt nur, wenn er blufft —, +dann Showdown mit aufgedeckten Blättern und benanntem Rang. Der Pott +wächst mit den Erhöhungen beider Seiten. + +**Figuren am Tisch:** `scripts/gameplay/table_seating.gd` führt den +gewählten Gegner sichtbar zum runden Tisch der Aula und setzt ihn hin +(Marker `GegnerPlatz`/`DealerPlatz` an den Hockern); nach der Partie +gehen alle an ihren Ausgangsplatz zurück. **Dealer-Regel wie gefordert:** +Spielt jemand anderes, übernimmt Ridoc den Dealer-Platz; spielt Ridoc +selbst, dealt er sich selbst und besetzt nur den Gegnerplatz. Die +Sitzordnung greift **vor beiden Spielen** — die CR-Annahme, dass das auch +fürs Messerspiel gilt, ist so umgesetzt. + +**Beim Bauen gefunden und behoben:** Die erste Fassung sammelte die +`finished`-Signale mehrerer Tweens und wartete sie nacheinander ab — war +der erste Tween schon durch, brach das `await` mit „Error connecting to +signal" ab. Die Sonde meldete trotzdem grün, weil die Positionen am Ende +stimmten; erst das Fehlerprotokoll zeigte es. Jetzt läuft je Phase ein +einziger paralleler Tween (erst gehen alle, dann setzen sich alle). + +**Verifikation:** Sonde `dev_cr17_probe` 41/41 — volles Blatt ohne +Dubletten, alle neun Blatt-Ränge einzeln erkannt, Rangfolge, +Stichentscheid und Gleichstand; Platzhalter-Fall und Texturpfad-Muster; +fünf Karten je Seite, eigene offen, gegnerische vor dem Showdown +verdeckt und danach aufgedeckt; Setzrunde mit drei Aktionen; Gegnerin +läuft an und sitzt tiefer, Ridoc dealt, Tisch wird danach geräumt; +Ridoc als Gegner belegt nur den Gegnerplatz. Boot-Check über zehn Szenen +fehlerfrei, Log ohne Laufzeitfehler. Sonde vor dem Commit gelöscht. + ## 2026-07-21 — CR 18: Das Vierte Geschwader existiert (Ridoc, Sawyer, Liam, Dain) **Request:** CHANGEREQUESTS §18 — die halbe Staffel war stumm. Jede der diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 2cd02b5..68a0bde 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -8,7 +8,7 @@ > Stand: **2026-07-21**. Erledigt: Phasen 0–11, CR 1–8 (8a–8e), CR 11–16, > CR 23 (Asset-Pipeline steht und ist verifiziert) — **Wellen 0–3 komplett**, > v1 steht inhaltlich. Offen: die **Politur-Welle -> CR 17, 19, 21, 22** (Findings aus dem Akt-1-Testdurchlauf, Priorität; CR 18 +> CR 19, 21, 22** (Findings aus dem Akt-1-Testdurchlauf, Priorität; CR 17, CR 18 > und CR 20 sind erledigt), der > Primitiven-Austausch **CR 24** (Folge-Schritt aus CR 23), danach Welle 4 > (Akt 2: CR 9/10/8-magie/CR-16-Camp) und das eigene Kartenspiel (Stretch). @@ -91,8 +91,6 @@ Setzen auf bereits erledigte Systeme auf (CR 8 nicht nötig). **Priorität vor Welle 4.** Findings des Autors am fertigen v1-Umfang. Gut parallelisierbar; zwei davon sind reine Schreibarbeit. -- **CR 17 — Poker mit echten Karten + Figuren am Tisch.** UI-Overlay; Karten-PNGs - liefert der Autor, Platzhalter-Karten dürfen den Bau nicht blockieren. - **CR 21 — Blätter-Jagd auf Black-Flag-Gefühl.** Blatt reagiert auf Annäherung, bleibt aber garantiert einholbar. - **CR 19 + CR 22 — Schreibpass** (Dialoge + Journal/Lexicon) gegen die sechs @@ -124,7 +122,7 @@ Greifen erst nach Dreschen + erstem Flug; brauchen die CR-6-Basis. | 12 | Blätter jagen | 3 | erledigt (2026-07-20) | | 13 | Minispiele (Poker + Messerspiel) | 3 | erledigt (2026-07-20) | | 13-Rest | Eigenes Kartenspiel | — | offen (Stretch, kein v1-Ziel) | -| 17 | Poker: echte Karten + Figuren am Tisch | Politur | offen | +| 17 | Poker: echte Karten + Figuren am Tisch | Politur | **erledigt (2026-07-21)** — 52er-Blatt mit Rangbewertung, Setzrunden, Platzhalter-Karten; Gegner und Dealer laufen an und setzen sich | | 18 | Viertes Geschwader (Ridoc/Sawyer/Liam/Dain) | Politur | **erledigt (2026-07-21)** — vier Dialogbäume, vier Figuren im Hof, Staffel-Appell als Gruppenszene | | 19 | Stimmen-Schreibpass (Dialoge) | Politur | offen | | 20 | Viadukt-Respawn-Fix (Bug) | Politur | **erledigt (2026-07-21)** — Respawn am Checkpoint; dabei Wind-Beschleunigungs-Bug in `player.gd` mitbehoben | diff --git a/scenes/hub/aula.tscn b/scenes/hub/aula.tscn index bec935d..ce2f5ff 100644 --- a/scenes/hub/aula.tscn +++ b/scenes/hub/aula.tscn @@ -322,6 +322,9 @@ omni_range = 6.0 [node name="RunderTisch" type="StaticBody3D" parent="MinispielEcke"] transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 8.3, 0.425, 4.4) script = ExtResource("6_table") +guests_path = NodePath("../../Gaeste") +opponent_seat_path = NodePath("../Sitzplaetze/GegnerPlatz") +dealer_seat_path = NodePath("../Sitzplaetze/DealerPlatz") [node name="CollisionShape3D" type="CollisionShape3D" parent="MinispielEcke/RunderTisch"] shape = SubResource("CylinderShape3D_round") @@ -367,6 +370,14 @@ mesh = SubResource("CylinderMesh_stool") transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 8.3, 0.25, 5.5) mesh = SubResource("CylinderMesh_stool") +[node name="Sitzplaetze" type="Node3D" parent="MinispielEcke"] + +[node name="GegnerPlatz" type="Marker3D" parent="MinispielEcke/Sitzplaetze"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 9.4, 0, 4.4) + +[node name="DealerPlatz" type="Marker3D" parent="MinispielEcke/Sitzplaetze"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 8.3, 0, 5.5) + [node name="Eckenlicht" type="OmniLight3D" parent="MinispielEcke"] transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 8.3, 2.4, 4.4) light_color = Color(1, 0.8, 0.55, 1) diff --git a/scenes/ui/poker_game.tscn b/scenes/ui/poker_game.tscn index a9871d4..0cfac1a 100644 --- a/scenes/ui/poker_game.tscn +++ b/scenes/ui/poker_game.tscn @@ -7,7 +7,7 @@ content_margin_left = 14.0 content_margin_top = 12.0 content_margin_right = 14.0 content_margin_bottom = 12.0 -bg_color = Color(0.1, 0.12, 0.1, 0.95) +bg_color = Color(0.09, 0.14, 0.11, 0.96) corner_radius_top_left = 6 corner_radius_top_right = 6 corner_radius_bottom_right = 6 @@ -30,10 +30,10 @@ anchor_left = 0.5 anchor_top = 0.5 anchor_right = 0.5 anchor_bottom = 0.5 -offset_left = -320.0 -offset_top = -180.0 -offset_right = 320.0 -offset_bottom = 180.0 +offset_left = -380.0 +offset_top = -260.0 +offset_right = 380.0 +offset_bottom = 260.0 grow_horizontal = 2 grow_vertical = 2 theme_override_styles/panel = SubResource("StyleBoxFlat_panel") @@ -52,24 +52,51 @@ theme_override_colors/font_color = Color(0.94, 0.94, 0.88, 1) theme_override_font_sizes/font_size = 19 text = "Poker" -[node name="RoundLabel" type="Label" parent="Root/Panel/Margin/Content"] +[node name="Header" type="HBoxContainer" parent="Root/Panel/Margin/Content"] +theme_override_constants/separation = 16 + +[node name="RoundLabel" type="Label" parent="Root/Panel/Margin/Content/Header"] +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" -[node name="HandLabel" type="Label" parent="Root/Panel/Margin/Content"] -theme_override_colors/font_color = Color(0.9, 0.9, 0.85, 1) -theme_override_font_sizes/font_size = 17 -text = "Dein Blatt: —" +[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" + +[node name="TheirRow" type="VBoxContainer" parent="Root/Panel/Margin/Content"] +theme_override_constants/separation = 4 + +[node name="TheirLabel" type="Label" parent="Root/Panel/Margin/Content/TheirRow"] +theme_override_colors/font_color = Color(0.82, 0.78, 0.6, 1) +theme_override_font_sizes/font_size = 15 +text = "Gegner" + +[node name="TheirCards" type="HBoxContainer" parent="Root/Panel/Margin/Content/TheirRow"] +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.82, 0.78, 0.6, 1) +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="OwnRow" type="VBoxContainer" parent="Root/Panel/Margin/Content"] +theme_override_constants/separation = 4 + +[node name="OwnCards" type="HBoxContainer" parent="Root/Panel/Margin/Content/OwnRow"] +custom_minimum_size = Vector2(0, 92) +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" + [node name="Actions" type="HBoxContainer" parent="Root/Panel/Margin/Content"] -size_flags_vertical = 3 theme_override_constants/separation = 8 [node name="CallButton" type="Button" parent="Root/Panel/Margin/Content/Actions"] diff --git a/scripts/gameplay/game_table.gd b/scripts/gameplay/game_table.gd index c58b5a7..422e6ec 100644 --- a/scripts/gameplay/game_table.gd +++ b/scripts/gameplay/game_table.gd @@ -26,8 +26,15 @@ const STAKE_MARKS := [1, 3] const KNIFE_GAME_ID := "messerspiel" const POKER_GAME_ID := "poker" +const SEATING_SCRIPT := preload("res://scripts/gameplay/table_seating.gd") + @export var exhausted_line := "Der Tisch bleibt heute leer für dich — der Tag ist verbraucht." @export var broke_line := "Dein Beutel ist leer. Setzen kannst du nur noch dich selbst." +@export var guests_path: NodePath +@export var opponent_seat_path: NodePath +@export var dealer_seat_path: NodePath + +var _seating: Node var _is_player_in_range := false var _is_running := false @@ -42,6 +49,10 @@ var _data: Dictionary = {} func _ready() -> void: _interaction_area.body_entered.connect(_on_body_entered) _interaction_area.body_exited.connect(_on_body_exited) + _seating = Node.new() + _seating.name = "TableSeating" + _seating.set_script(SEATING_SCRIPT) + add_child(_seating) var file := FileAccess.open(GAMES_PATH, FileAccess.READ) if file == null: push_error("Spieltisch-Daten nicht lesbar: %s" % GAMES_PATH) @@ -163,9 +174,24 @@ func _play_session(menu: CanvasLayer) -> void: if stake <= 0: return TimeSystem.try_spend_slot() + await _seat_players(str(opponent.get("id", ""))) await _say(str(opponent.get("intro_line", ""))) var result := await _play_game(game_id, config, opponent, stake) await _report(config, opponent, result) + await _seating.release_players() + + +## Holt Gegner und Dealer sichtbar an den Tisch (CR 17). Spielt Ridoc +## selbst, dealt er sich auch selbst und der Dealer-Platz bleibt frei; +## sonst übernimmt Ridoc das Geben. Fehlen die Marker in der Szene, +## läuft die Partie ohne Sitzordnung weiter. +func _seat_players(opponent_id: String) -> void: + var guests := get_node_or_null(guests_path) as Node3D + var opponent_seat := get_node_or_null(opponent_seat_path) as Node3D + var dealer_seat := get_node_or_null(dealer_seat_path) as Node3D + if guests == null: + return + await _seating.seat_players(guests, opponent_id, opponent_seat, dealer_seat) ## Fragt den Einsatz ab; ohne Marken bleibt nur das eigene Ansehen. diff --git a/scripts/gameplay/table_seating.gd b/scripts/gameplay/table_seating.gd new file mode 100644 index 0000000..594e8c7 --- /dev/null +++ b/scripts/gameplay/table_seating.gd @@ -0,0 +1,103 @@ +extends Node +## Figuren am Spieltisch (CR 17). +## +## Wer mitspielt, ist auch da: Der gewählte Gegner läuft sichtbar zum +## runden Tisch der Aula und nimmt Platz, der Dealer ebenso. Nach der +## Partie gehen beide an ihren Ausgangsplatz zurück. +## +## Dealer-Regel aus CR 17: Spielt Ridoc selbst, dealt er sich auch selbst +## und besetzt nur den Gegner-Platz. Spielt jemand anderes, übernimmt +## Ridoc den Dealer-Platz. Fehlt Ridoc in der Szene, bleibt der Platz +## leer — das Spiel läuft trotzdem. +## +## Gilt für **beide** Spiele am Tisch, Poker wie Messerspiel (Annahme aus +## CR 17, vom Autor bestätigt). Rein kosmetisch: Kein Ausgang, kein Wert +## und kein Flag hängt daran. + +const WALK_SPEED := 2.2 +const SIT_DROP := 0.35 +const SIT_SECONDS := 0.25 +const DEALER_ID := "ridoc" + +var _seated: Array[Dictionary] = [] + + +## Führt Gegner und Dealer an den Tisch (Coroutine). guests ist die +## Gaeste-Node der Aula, seats liefert die Marker. Alle Figuren laufen +## gleichzeitig, danach setzen sie sich gleichzeitig. +func seat_players(guests: Node3D, opponent_id: String, opponent_seat: Node3D, dealer_seat: Node3D) -> void: + var opponent := _find_guest(guests, opponent_id) + var dealer := _find_guest(guests, DEALER_ID) + var targets: Array[Dictionary] = [] + if opponent != null and opponent_seat != null: + targets.append({ "figure": opponent, "target": opponent_seat.global_position }) + if dealer != null and dealer != opponent and dealer_seat != null: + targets.append({ "figure": dealer, "target": dealer_seat.global_position }) + if targets.is_empty(): + return + for entry in targets: + _seated.append({ "figure": entry["figure"], "origin": entry["figure"].global_position }) + await _move_all(targets) + await _drop_all(targets, -SIT_DROP) + + +## Schickt alle gesetzten Figuren an ihren Ausgangsplatz zurück. +func release_players() -> void: + var targets: Array[Dictionary] = [] + for entry in _seated: + var figure: Node3D = entry["figure"] + if is_instance_valid(figure): + targets.append({ "figure": figure, "target": entry["origin"] }) + _seated.clear() + if targets.is_empty(): + return + await _drop_all(targets, SIT_DROP) + await _move_all(targets) + + +## Sitzt gerade jemand am Tisch? (für Sonden) +func seated_count() -> int: + return _seated.size() + + +## Ist diese Figur gerade am Tisch? (für Sonden) +func is_seated(figure: Node3D) -> bool: + for entry in _seated: + if entry["figure"] == figure: + return true + return false + + +## Lässt alle Figuren gleichzeitig zu ihrem Ziel laufen; die Höhe bleibt +## dabei unangetastet, gelaufen wird nur über den Boden. +func _move_all(targets: Array[Dictionary]) -> void: + var tween := create_tween() + tween.set_parallel(true) + for entry in targets: + var figure: Node3D = entry["figure"] + var target: Vector3 = entry["target"] + var ground_target := Vector3(target.x, figure.global_position.y, target.z) + var duration := maxf(figure.global_position.distance_to(ground_target) / WALK_SPEED, 0.05) + tween.tween_property(figure, "global_position", ground_target, duration) + await tween.finished + + +## Senkt oder hebt alle Figuren gleichzeitig — Hinsetzen und Aufstehen. +func _drop_all(targets: Array[Dictionary], offset: float) -> void: + var tween := create_tween() + tween.set_parallel(true) + for entry in targets: + var figure: Node3D = entry["figure"] + tween.tween_property(figure, "global_position:y", figure.global_position.y + offset, SIT_SECONDS) + await tween.finished + + +## Sucht eine Gast-Figur über ihren NameLabel-Text oder Knotennamen. +func _find_guest(guests: Node3D, npc_id: String) -> Node3D: + if guests == null or npc_id.is_empty(): + return null + var wanted := npc_id.to_lower() + for child in guests.get_children(): + if str(child.name).to_lower() == wanted: + return child as Node3D + return null diff --git a/scripts/gameplay/table_seating.gd.uid b/scripts/gameplay/table_seating.gd.uid new file mode 100644 index 0000000..ad4e833 --- /dev/null +++ b/scripts/gameplay/table_seating.gd.uid @@ -0,0 +1 @@ +uid://vnsmeclg0boq diff --git a/scripts/ui/card_deck.gd b/scripts/ui/card_deck.gd new file mode 100644 index 0000000..eafae62 --- /dev/null +++ b/scripts/ui/card_deck.gd @@ -0,0 +1,179 @@ +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] diff --git a/scripts/ui/card_deck.gd.uid b/scripts/ui/card_deck.gd.uid new file mode 100644 index 0000000..a2c8ebc --- /dev/null +++ b/scripts/ui/card_deck.gd.uid @@ -0,0 +1 @@ +uid://dda2yao744yl diff --git a/scripts/ui/card_view.gd b/scripts/ui/card_view.gd new file mode 100644 index 0000000..852f637 --- /dev/null +++ b/scripts/ui/card_view.gd @@ -0,0 +1,101 @@ +extends Control +## Anzeige einer einzelnen Spielkarte (CR 17). +## +## Zeigt die PNG aus assets/ui/cards/, sobald der Autor sie geliefert hat +## (Pfad kommt aus data/minigames/cards.json). Fehlt die Datei, zeichnet +## diese Ansicht eine **Platzhalter-Karte**: weißes Rechteck mit Wert und +## Farbzeichen, rot oder schwarz. Beide Zustände sind gleich groß und +## gleich bedienbar — das Spiel wartet nicht auf die Grafiken. +## +## Verdeckte Karten (show_back) zeigen den Rücken; auch dafür gibt es +## einen Platzhalter, damit die Gegnerhand vor dem Showdown zu ist. + +const CARD_SIZE := Vector2(64, 92) +const CORNER_RADIUS := 5 + +var _card: Dictionary = {} +var _is_face_up := true + + +## Baut die Kinder-Knoten einmalig auf. +func _ready() -> void: + custom_minimum_size = CARD_SIZE + size = CARD_SIZE + + +## Zeigt eine Karte offen an. +func show_card(card: Dictionary, deck: CardDeck) -> void: + _card = card + _is_face_up = true + _rebuild(deck) + + +## Zeigt die Rückseite (Gegnerhand vor dem Showdown). +func show_back(deck: CardDeck) -> void: + _card = {} + _is_face_up = false + _rebuild(deck) + + +## Die aktuell gezeigte Karte (für Sonden). +func get_card() -> Dictionary: + return _card + + +## Liegt die Karte offen? (für Sonden) +func is_face_up() -> bool: + return _is_face_up + + +## Baut die Anzeige neu: Textur, wenn vorhanden, sonst Platzhalter. +func _rebuild(deck: CardDeck) -> void: + for child in get_children(): + child.queue_free() + var path := "" + if _is_face_up and deck != null: + path = deck.texture_path(_card) + elif deck != null and not deck.texture_dir.is_empty(): + path = deck.texture_dir + "ruecken.png" + if not path.is_empty() and ResourceLoader.exists(path): + var texture_rect := TextureRect.new() + texture_rect.texture = load(path) + texture_rect.expand_mode = TextureRect.EXPAND_IGNORE_SIZE + texture_rect.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED + texture_rect.set_anchors_preset(Control.PRESET_FULL_RECT) + add_child(texture_rect) + return + _build_placeholder() + + +## Zeichnet die Platzhalter-Karte aus Rechteck und Text. +func _build_placeholder() -> void: + var panel := PanelContainer.new() + panel.set_anchors_preset(Control.PRESET_FULL_RECT) + var style := StyleBoxFlat.new() + style.corner_radius_top_left = CORNER_RADIUS + style.corner_radius_top_right = CORNER_RADIUS + style.corner_radius_bottom_left = CORNER_RADIUS + style.corner_radius_bottom_right = CORNER_RADIUS + style.border_width_left = 2 + style.border_width_top = 2 + style.border_width_right = 2 + style.border_width_bottom = 2 + if not _is_face_up: + style.bg_color = Color(0.22, 0.26, 0.38) + style.border_color = Color(0.42, 0.46, 0.58) + else: + style.bg_color = Color(0.96, 0.95, 0.91) + style.border_color = Color(0.35, 0.33, 0.3) + panel.add_theme_stylebox_override("panel", style) + add_child(panel) + if not _is_face_up: + return + var label := Label.new() + label.set_anchors_preset(Control.PRESET_FULL_RECT) + label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER + label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER + label.text = "%s\n%s" % [str(_card.get("label", "?")), str(_card.get("symbol", "?"))] + label.add_theme_font_size_override("font_size", 22) + var is_red: bool = bool(_card.get("is_red", false)) + label.add_theme_color_override("font_color", Color(0.72, 0.16, 0.16) if is_red else Color(0.12, 0.12, 0.14)) + add_child(label) diff --git a/scripts/ui/card_view.gd.uid b/scripts/ui/card_view.gd.uid new file mode 100644 index 0000000..e1bab4e --- /dev/null +++ b/scripts/ui/card_view.gd.uid @@ -0,0 +1 @@ +uid://qk35djhdqj diff --git a/scripts/ui/poker_game.gd b/scripts/ui/poker_game.gd index 727b0ff..04c71ae 100644 --- a/scripts/ui/poker_game.gd +++ b/scripts/ui/poker_game.gd @@ -1,38 +1,53 @@ extends CanvasLayer -## Poker am runden Tisch (CR 13). +## Poker am runden Tisch — mit sichtbaren Karten (CR 17, ersetzt die +## Menü-Variante aus CR 13). ## -## Kein volles Regelwerk, sondern das, worum es beim Pokern in der Aula -## wirklich geht: lesen oder gelesen werden. Jede Runde bekommen beide -## ein Blatt (0–100). Tyrveil sieht sein eigenes und ein **Tell** des -## Gegners — eine Andeutung, die umso öfter lügt, je höher die -## bluff_rate des Gegenübers ist (Imogen blufft, Wren fast nie). Dann: -## mitgehen, erhöhen oder aussteigen. +## 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). ## -## Erhöhen verdoppelt den Einsatz der Runde, Aussteigen kostet nur den -## Ante. play() liefert als Coroutine den Marken-Saldo der Partie; ob -## Tyrveil sich das leisten kann, prüft der Spieltisch vorher. +## 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. +## +## Die Karten-Grafiken liefert der Autor unter assets/ui/cards/ nach; bis +## dahin zeichnet card_view.gd Platzhalter. Am Ablauf ändert das nichts. 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 +var _deck := CardDeck.new() var _is_open := false +var _own_hand: Array = [] +var _their_hand: Array = [] @onready var _title_label: Label = $Root/Panel/Margin/Content/TitleLabel -@onready var _round_label: Label = $Root/Panel/Margin/Content/RoundLabel -@onready var _hand_label: Label = $Root/Panel/Margin/Content/HandLabel +@onready var _round_label: Label = $Root/Panel/Margin/Content/Header/RoundLabel +@onready var _pot_label: Label = $Root/Panel/Margin/Content/Header/PotLabel +@onready var _their_cards: HBoxContainer = $Root/Panel/Margin/Content/TheirRow/TheirCards +@onready var _their_label: Label = $Root/Panel/Margin/Content/TheirRow/TheirLabel +@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 _raise_button: Button = $Root/Panel/Margin/Content/Actions/RaiseButton @onready var _fold_button: Button = $Root/Panel/Margin/Content/Actions/FoldButton -## Startet verborgen und verbindet die drei Aktionen. +## Startet verborgen, lädt das Blatt und verbindet die Aktionen. func _ready() -> void: visible = false + _deck.load_data() _call_button.pressed.connect(_act.bind(ACTION_CALL)) _raise_button.pressed.connect(_act.bind(ACTION_RAISE)) _fold_button.pressed.connect(_act.bind(ACTION_FOLD)) @@ -41,23 +56,14 @@ func _ready() -> void: ## Spielt die Partie (Coroutine) und liefert den Marken-Saldo. func play(config: Dictionary, opponent: Dictionary) -> int: _title_label.text = "%s — gegen %s" % [str(config.get("title", "Poker")), 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 balance := 0 for index in rounds: - _round_label.text = "Runde %d / %d" % [index + 1, rounds] - var own_hand := randi_range(0, 100) - var their_hand := randi_range(0, 100) - _hand_label.text = "Dein Blatt: %d von 100" % own_hand - _tell_label.text = _tell_for(their_hand, opponent) - _result_label.text = "" - _is_open = true - _call_button.grab_focus.call_deferred() - var action: int = await acted - balance += _resolve(action, own_hand, their_hand, ante, raise_multiplier) - await get_tree().create_timer(1.2).timeout + balance += await _play_round(index, rounds, ante, raise_multiplier, opponent) visible = false return balance @@ -67,26 +73,95 @@ func act(action: int) -> void: _act(action) -## Wertet eine Runde aus und liefert die Marken-Änderung. -func _resolve(action: int, own_hand: int, their_hand: int, ante: int, raise_multiplier: int) -> int: +## Das eigene Blatt der laufenden Runde (für Sonden). +func get_own_hand() -> Array: + return _own_hand + + +## Das Blatt des Gegners (für Sonden). +func get_their_hand() -> Array: + return _their_hand + + +## Das Kartenblatt dieser Partie (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: + _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 + + _round_label.text = "Runde %d / %d" % [index + 1, rounds] + _pot_label.text = "Pott: %d" % pot + _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 + if action == ACTION_FOLD: - _result_label.text = "Ausgestiegen. −%d Marken." % ante + _result_label.text = "Ausgestiegen. Der Ante bleibt liegen. −%d" % ante + await _pause() return -ante - var stake := ante * raise_multiplier if action == ACTION_RAISE else ante - if own_hand > their_hand: - _result_label.text = "%d gegen %d — du nimmst den Pott. +%d Marken." % [own_hand, their_hand, stake] + + 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 own_hand < their_hand: - _result_label.text = "%d gegen %d — der Pott geht rüber. −%d Marken." % [own_hand, their_hand, 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) + _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] + 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] + await _pause() return -stake - _result_label.text = "%d gegen %d — geteilt." % [own_hand, their_hand] + _result_label.text = "Gleichstand. Der Pott wird geteilt." + await _pause() return 0 -## Baut das Tell des Gegners: mit bluff_rate zeigt es das Gegenteil der -## Wahrheit. Wer oft blufft, ist genau deshalb schwerer zu lesen. -func _tell_for(their_hand: int, opponent: Dictionary) -> String: - var is_strong := their_hand >= 50 +## 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) + 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: + return ACTION_FOLD + if judged > 0.45 or is_bluffing: + return ACTION_RAISE + return ACTION_CALL + + +## 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")) @@ -95,6 +170,25 @@ func _tell_for(their_hand: int, opponent: Dictionary) -> String: return "%s zählt die eigenen Marken nach. Zum zweiten Mal." % name +## Legt ein Blatt in eine Reihe; is_face_up entscheidet über offen oder 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) + + +## Lässt das Ergebnis kurz stehen, damit man die Blätter sieht. +func _pause() -> void: + await get_tree().create_timer(REVEAL_SECONDS).timeout + + ## Meldet die Aktion genau einmal. func _act(action: int) -> void: if not _is_open: