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>
256 lines
9.4 KiB
GDScript
256 lines
9.4 KiB
GDScript
extends StaticBody3D
|
|
## Der Spieltisch in der Minispiel-Ecke der Aula (CR 13).
|
|
##
|
|
## Walk-up wie die Trainings-Stationen: interact in Reichweite setzt
|
|
## Tyrveil an den runden Tisch. Gewählt wird erst das Spiel
|
|
## (Messerspiel oder Poker), dann der Gegner, dann der Einsatz — wer
|
|
## keine Marken mehr hat, kann nur noch sein Staffel-Ansehen setzen.
|
|
## Eine Partie verbraucht den Tages-Slot.
|
|
##
|
|
## Der Einsatz ist echt. Marken wechseln den Besitzer, Sieg oder
|
|
## Niederlage verschieben Staffel-Ansehen und den Beziehungswert des
|
|
## Gegenübers, und das Messerspiel schneidet: Wer danebenschlägt,
|
|
## verliert dauerhaft einen Punkt Schnelligkeit (derselbe Verletzungs-
|
|
## Malus wie beim Tag-9-Hinterhalt) und spürt das im nächsten Kampf.
|
|
##
|
|
## Die Gegner spielen wie sie sind (CHARACTERS.md): Ridoc zockt und
|
|
## nimmt jedes Spiel an, Imogen blufft die halbe Runde durch, Wren
|
|
## setzt ungern und rührt das Messer überhaupt nicht an.
|
|
|
|
const MENU_SCENE := preload("res://scenes/ui/table_menu.tscn")
|
|
const KNIFE_SCENE := preload("res://scenes/ui/knife_game.tscn")
|
|
const POKER_SCENE := preload("res://scenes/ui/poker_game.tscn")
|
|
const GAMES_PATH := "res://data/minigames/table_games.json"
|
|
const STAFFEL_FACTION_ID := "staffel"
|
|
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
|
|
var _data: Dictionary = {}
|
|
|
|
@onready var _prompt_label: Label3D = $PromptLabel
|
|
@onready var _interaction_area: Area3D = $InteractionArea
|
|
@onready var _bubble: SpeechBubble = $SpeechBubble
|
|
|
|
|
|
## Lädt die Spieldaten und verbindet die Reichweiten-Signale.
|
|
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)
|
|
return
|
|
var parsed: Variant = JSON.parse_string(file.get_as_text())
|
|
file.close()
|
|
if parsed is Dictionary and parsed.get("games") is Dictionary:
|
|
_data = parsed
|
|
else:
|
|
push_error("Spieltisch-Daten sind ungültig: %s" % GAMES_PATH)
|
|
|
|
|
|
## Setzt sich bei interact in Reichweite an den Tisch.
|
|
func _unhandled_input(event: InputEvent) -> void:
|
|
if not _is_player_in_range or _is_running:
|
|
return
|
|
if DialogueSystem.is_dialogue_active:
|
|
return
|
|
if not event.is_action_pressed("interact"):
|
|
return
|
|
_run_table()
|
|
|
|
|
|
## Alle Gegner, die ein bestimmtes Spiel mitspielen.
|
|
func get_opponents_for(game_id: String) -> Array:
|
|
var result: Array = []
|
|
for opponent in _data.get("opponents", []):
|
|
if game_id in opponent.get("games", []):
|
|
result.append(opponent)
|
|
return result
|
|
|
|
|
|
## Wertet eine Messerspiel-Partie aus: saubere Runden bringen Marken und
|
|
## Ansehen, ein Fehlschlag kostet den Einsatz und schneidet in die Hand.
|
|
## Liefert die Zusammenfassung für die Abschlusszeile.
|
|
func resolve_knife(config: Dictionary, opponent: Dictionary, clean_rounds: int, stake: int) -> Dictionary:
|
|
var rounds := int(config.get("rounds", 5))
|
|
var is_won := clean_rounds >= rounds
|
|
var result := { "is_won": is_won, "marks": 0, "is_injured": not is_won }
|
|
if is_won:
|
|
var winnings := clean_rounds * int(config.get("reward_marks_per_round", 1)) * stake
|
|
result["marks"] = GameState.adjust_marks(winnings)
|
|
FactionSystem.adjust_standing(STAFFEL_FACTION_ID, 1)
|
|
RelationshipSystem.adjust_relationship(str(opponent.get("id", "")), 1)
|
|
return result
|
|
result["marks"] = GameState.adjust_marks(-stake)
|
|
GameState.increase_stat("agility", -int(config.get("injury_agility_malus", 1)))
|
|
GameState.set_story_flag(str(config.get("injury_flag", "messerspiel_schnitt")), true)
|
|
return result
|
|
|
|
|
|
## Wertet eine Poker-Partie aus: der Saldo wird mit dem Einsatz
|
|
## multipliziert. Das Ansehen in der Staffel folgt dem Ergebnis — wer
|
|
## gewinnt, steht besser da. Der Beziehungswert des Gegenübers steigt
|
|
## dagegen in beide Richtungen: Man hat den Abend miteinander verbracht,
|
|
## und wer verliert, hat dem anderen einen guten Abend geschenkt.
|
|
func resolve_poker(opponent: Dictionary, balance: int, stake: int) -> Dictionary:
|
|
var total := balance * stake
|
|
var result := { "is_won": total > 0, "marks": GameState.adjust_marks(total) }
|
|
if total == 0:
|
|
return result
|
|
FactionSystem.adjust_standing(STAFFEL_FACTION_ID, 1 if total > 0 else -1)
|
|
RelationshipSystem.adjust_relationship(str(opponent.get("id", "")), 1)
|
|
return result
|
|
|
|
|
|
## Führt die ganze Tisch-Runde als Coroutine: Auswahl, Einsatz, Partie,
|
|
## Auswertung. Bricht der Spieler vor dem Einsatz ab, bleibt der Tag heil.
|
|
func _run_table() -> void:
|
|
if _data.is_empty():
|
|
return
|
|
if TimeSystem.is_current_slot_used:
|
|
_bubble.show_line(exhausted_line)
|
|
return
|
|
var player := get_tree().get_first_node_in_group("player")
|
|
if player == null:
|
|
return
|
|
_is_running = true
|
|
player.set_control_locked(true)
|
|
Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
|
|
var menu: CanvasLayer = MENU_SCENE.instantiate()
|
|
add_child(menu)
|
|
await _play_session(menu)
|
|
menu.queue_free()
|
|
Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
|
|
player.set_control_locked(false)
|
|
_is_running = false
|
|
|
|
|
|
## Wählt Spiel, Gegner und Einsatz und spielt die Partie.
|
|
func _play_session(menu: CanvasLayer) -> void:
|
|
var games: Dictionary = _data.get("games", {})
|
|
var game_ids: Array = [KNIFE_GAME_ID, POKER_GAME_ID]
|
|
var titles: Array = []
|
|
for game_id in game_ids:
|
|
titles.append(str(games.get(game_id, {}).get("title", game_id)))
|
|
var game_index: int = await menu.choose("Am runden Tisch. Womit?", titles)
|
|
if game_index < 0:
|
|
return
|
|
var game_id := str(game_ids[game_index])
|
|
var config: Dictionary = games.get(game_id, {})
|
|
await _say(str(config.get("rules_line", "")))
|
|
|
|
var opponents := get_opponents_for(game_id)
|
|
if opponents.is_empty():
|
|
return
|
|
var names: Array = []
|
|
for opponent in opponents:
|
|
names.append(str(opponent.get("name", "?")))
|
|
var opponent_index: int = await menu.choose("Gegen wen?", names)
|
|
if opponent_index < 0:
|
|
return
|
|
var opponent: Dictionary = opponents[opponent_index]
|
|
if game_id == KNIFE_GAME_ID and opponent.has("refuses_knife_line"):
|
|
await _say(str(opponent["refuses_knife_line"]))
|
|
return
|
|
|
|
var stake := await _choose_stake(menu)
|
|
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.
|
|
func _choose_stake(menu: CanvasLayer) -> int:
|
|
var options: Array = []
|
|
var stakes: Array = []
|
|
for amount in STAKE_MARKS:
|
|
if GameState.marks >= amount:
|
|
options.append("%d Marken" % amount)
|
|
stakes.append(amount)
|
|
if options.is_empty():
|
|
await _say(broke_line)
|
|
options.append("Ansehen setzen")
|
|
stakes.append(1)
|
|
var index: int = await menu.choose("Wie hoch?", options)
|
|
if index < 0:
|
|
return 0
|
|
return int(stakes[index])
|
|
|
|
|
|
## Spielt die gewählte Partie und liefert deren Auswertung.
|
|
func _play_game(game_id: String, config: Dictionary, opponent: Dictionary, stake: int) -> Dictionary:
|
|
if game_id == KNIFE_GAME_ID:
|
|
var knife: CanvasLayer = KNIFE_SCENE.instantiate()
|
|
add_child(knife)
|
|
var clean: int = await knife.play(config)
|
|
knife.queue_free()
|
|
return resolve_knife(config, opponent, clean, stake)
|
|
var poker: CanvasLayer = POKER_SCENE.instantiate()
|
|
add_child(poker)
|
|
var balance: int = await poker.play(config, opponent)
|
|
poker.queue_free()
|
|
return resolve_poker(opponent, balance, stake)
|
|
|
|
|
|
## Schließt die Partie mit der Zeile des Gegners ab — und, wenn es
|
|
## Blut gegeben hat, mit dem Schnitt.
|
|
func _report(config: Dictionary, opponent: Dictionary, result: Dictionary) -> void:
|
|
if bool(result.get("is_injured", false)):
|
|
await _say(str(config.get("injury_line", "")))
|
|
var line_key := "player_win_line" if bool(result.get("is_won", false)) else "player_loss_line"
|
|
await _say(str(opponent.get(line_key, "")))
|
|
|
|
|
|
## Zeigt eine Zeile über der Blase und wartet ihr Ende ab.
|
|
func _say(text: String) -> void:
|
|
if text.is_empty():
|
|
return
|
|
_bubble.show_line(text)
|
|
await _bubble.line_finished
|
|
|
|
|
|
## Blendet den Prompt ein, sobald der Spieler die Reichweite betritt.
|
|
func _on_body_entered(_body: Node3D) -> void:
|
|
_is_player_in_range = true
|
|
_prompt_label.visible = true
|
|
|
|
|
|
## Blendet den Prompt aus, wenn der Spieler die Reichweite verlässt.
|
|
func _on_body_exited(_body: Node3D) -> void:
|
|
_is_player_in_range = false
|
|
_prompt_label.visible = false
|