windgeschworen/scripts/autoloads/dialogue_system.gd
danny 2875ba7629 DialogueSystem: Segment-Ende markiert den Dialog nicht als gefuehrt
Endete ein Durchlauf an seinem stop_node, galt die Datei schon als
gefuehrt, und jedes folgende Segment lief ohne Effekte: Story-Flags und
Klinge/Herz-Verschiebungen fielen still weg. In Akt 3 K3 betraf das alles
nach dem Anflug (akt3_dorf_done, akt3_fall_done, akt3_kinder_done, alle
Antwort-Effekte). Cassians Dreschen segmentiert auch, seine Datei hat aber
keine Effekte, dort aendert sich nichts.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 18:32:16 +02:00

545 lines
23 KiB
GDScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

extends Node
## Daten-getriebenes Dialog-System (Autoload, SPEC.md Abschnitte 6 und 8).
##
## Spielt verzweigte Dialogbäume aus JSON-Dateien unter data/dialogue ab.
## Jede Zeile erscheint gut lesbar in der Dialog-Box am unteren Bildrand
## (dialogue_box.tscn, inklusive Antwortauswahl) und zusätzlich als
## Sprechblase über dem Kopf des Sprechers (Kind-Node "SpeechBubble");
## die gewählte Antwort läuft über Tyrveils eigene Blase. Options-Tags
## verschieben die Klinge-↔-Herz-Achse (blade_heart) und Beziehungswerte
## (relationship: NPC-ID -> Delta) — aber nur beim ERSTEN Durchlauf eines
## Dialogs: Abgeschlossene Dialoge merkt sich GameState.completed_dialogues
## (dort statt im StorySystem, weil nur GameState bereits gespeichert und
## geladen wird und das Flag Save/Load überleben muss). Wiederholtes
## Ansprechen spielt den Text erneut ab, ohne Werte zu verschieben.
## Die Actions cancel und dialogue_abort (X) brechen einen laufenden
## Dialog ab; Tyrveil sagt dem Gegenüber dabei eine zufällig gewählte
## Zeile aus dem abort_lines-Array der Dialog-Datei an (Fallback:
## abort_line bzw. Standard) — so klingt der Abschied pro Charakter
## unterschiedlich. Dialoge mit "can_abort": false (z. B. der
## Wren-Moment am Viadukt) sind nicht abbrechbar: Der Spieler muss eine
## Option wählen, bevor die Szene fortschreitet. Options-Tag story_flag
## (Flag-Name -> Wert) schreibt Story-Flags in den GameState (z. B. WIE
## Wren gerettet wurde). Gewichtete Unsicherheit (Phase 11, CR 3):
## Optionen können statt "next" einen verdeckten Erfolgs-Check tragen
## ("check": base + Stat-Wert + Beziehung/2, geklemmt 5–95 %), der
## zwischen success_next und fail_next entscheidet — die Chance wird dem
## Spieler NIE angezeigt, damit sich die „richtige" Wahl nicht ablesen
## lässt. Ausgang ≠ Ton: Effekt-Tags der Option gelten unabhängig vom
## Wurf. Abgebrochene Dialoge gelten nur dann als geführt, wenn in diesem
## Durchlauf bereits Options-Effekte angewendet wurden — so bleibt der
## Erst-Durchlauf-Effekt erhalten, ohne dass Abbrechen zum Werte-Farming
## taugt. dialogue_started/dialogue_finished erlauben es, Spielerbewegung
## und UI während des Dialogs zu sperren.
##
## **Autoren-Tags (CR 43)** — vier Felder, die die Dialogdateien seit Akt 2
## durchgängig benutzen:
## - `requires_flag` (Option): Die Option erscheint nur, wenn das genannte
## Story-Flag gesetzt ist — sonst wird sie **ausgeblendet**, nicht
## ausgegraut. Verhindert, dass das Spiel Erinnerungen behauptet, die der
## Spieler nie hatte.
## - `bond` (Option): verschiebt die Drachenbindung, analog zu
## `relationship`, über DragonBondSystem.adjust_bond().
## - `time_card` (Dateikopf): Vollbild-Titelkarte vor dem ersten Knoten,
## überspringbar — ersetzt den abgeschafften Erzähler bei Zeitsprüngen
## (CR 37).
## - `signet_lines` (Knoten): Zeilen-Tabelle je Signet-ID; gewählt wird die
## Zeile zu Tyrveils gewürfelter Erstkraft, Rückfall auf "default".
##
## **`no_input` (Knoten, CR 44)** — der Manifestations-Moment. Solange ein so
## markierter Knoten läuft, ist JEDE Eingabe wirkungslos: kein Überspringen,
## kein Abbrechen, keine Antwortauswahl (Optionen an einem solchen Knoten
## werden ignoriert), und das Pausenmenü greift ohnehin nicht in laufende
## Dialoge. Das Ereignis wird verschluckt, damit auch nichts anderes darauf
## reagiert. Danach hält das Bild `INPUT_LOCK_HOLD` länger — die halbe
## Sekunde zu viel, nach der Tyrveil noch steht. Grund: Wer dort drücken
## kann, glaubt hinterher, ER habe es getan; dann ist Liams Tod eine
## verpasste Reaktion statt eines Zufalls (AKT3.md §9 ①b).
##
## `story_flag` gilt an **Optionen** wie an **Knoten** (CR 49): Ein Knoten setzt
## seine Flags, sobald er gespielt wird — beides nur beim ersten Durchlauf.
##
## `_regie` und `_entwurf` sind **reine Autorenfelder** und werden hier
## bewusst NIE gelesen — sie dürfen nie im Spiel erscheinen.
signal dialogue_started(dialogue_id: String)
## Meldet jeden Knoten, bevor er gespielt wird — der Anker fuer Systeme, die
## an einzelnen Stellen im Text umschalten (CR 45: der Fall in Akt 3 K3).
signal node_started(dialogue_id: String, node_id: String)
signal dialogue_finished(dialogue_id: String)
const BOX_SCENE := preload("res://scenes/ui/dialogue_box.tscn")
const PLAYER_SPEAKER_ID := "player"
const FALLBACK_LINE_SECONDS := 2.5
const DEFAULT_ABORT_LINE := "Nicht jetzt. Wir reden später weiter."
const TIME_CARD_SECONDS := 2.6
const INPUT_LOCK_HOLD := 0.5
const TIME_CARD_FADE := 0.5
var is_dialogue_active := false
var is_abort_allowed := true
var _speakers: Dictionary = {}
var _speaker_names: Dictionary = {}
var _is_effect_pass := true
var _is_abort_requested := false
var _is_skip_requested := false
var _is_input_locked := false
var _has_applied_effects := false
var _abort_lines: Array = [DEFAULT_ABORT_LINE]
var _box: CanvasLayer
## Startet einen Dialog aus einer JSON-Datei. speakers bildet Sprecher-IDs
## aus den Dialog-Knoten auf Szenen-Nodes mit SpeechBubble-Kind ab; der
## Spieler läuft unter der ID "player". Läuft bereits ein Dialog, passiert
## nichts.
##
## start_node überschreibt den Einstiegsknoten (leerer String = data.start);
## stop_node beendet den Durchlauf, SOBALD dieser Knoten erreicht wird, OHNE
## ihn zu spielen (leerer String = bis zum natürlichen Ende). Beides erlaubt
## es einer Szene, denselben Dialogbaum in Segmenten zu fahren und dazwischen
## eigene Beats einzuschieben (CR 33d: Cassians `kampf`-Pause und der
## `toeten`-Augen-Effekt) — ohne Umbau am JSON-Schema.
func start_dialogue(dialogue_path: String, speakers: Dictionary, start_node := "", stop_node := "") -> void:
if is_dialogue_active:
return
var data := _load_dialogue(dialogue_path)
if data.is_empty():
return
var dialogue_id := str(data["id"])
_speakers = speakers.duplicate()
_speaker_names = data.get("speakers", {})
_is_effect_pass = not GameState.has_completed_dialogue(dialogue_id)
_is_abort_requested = false
_is_skip_requested = false
_is_input_locked = false
_has_applied_effects = false
_abort_lines = data.get("abort_lines", [])
if _abort_lines.is_empty():
_abort_lines = [str(data.get("abort_line", DEFAULT_ABORT_LINE))]
is_abort_allowed = bool(data.get("can_abort", true))
is_dialogue_active = true
dialogue_started.emit(dialogue_id)
_run_dialogue(data, start_node, stop_node)
## Merkt Abbruch- (cancel/dialogue_abort) und Skip-Wünsche
## (confirm/interact) während laufender Dialog-Zeilen vor; offene
## Antwortauswahlen behandelt die Dialog-Box selbst. Skippen springt
## Zeile für Zeile bis zur nächsten Auswahl und funktioniert auch in
## nicht abbrechbaren Dialogen.
func _unhandled_input(event: InputEvent) -> void:
if not is_dialogue_active:
return
if _is_input_locked:
get_viewport().set_input_as_handled()
return
if _box != null and _box.has_open_options():
return
if event.is_action_pressed("confirm") or event.is_action_pressed("interact"):
_is_skip_requested = true
return
if not is_abort_allowed:
return
if event.is_action_pressed("cancel") or event.is_action_pressed("dialogue_abort"):
_is_abort_requested = true
## Gibt zurück, ob der Node Sprecher des gerade laufenden Dialogs ist
## (z. B. für Wander-KI-Pause und Ambient-Abbruch).
func is_speaker(node: Node) -> bool:
return is_dialogue_active and _speakers.values().has(node)
## Liest und validiert eine Dialog-Datei; leeres Dictionary bei Fehlern.
func _load_dialogue(dialogue_path: String) -> Dictionary:
var file := FileAccess.open(dialogue_path, FileAccess.READ)
if file == null:
push_error("Dialog-Datei nicht lesbar: %s (%s)" % [dialogue_path, error_string(FileAccess.get_open_error())])
return {}
var parsed: Variant = JSON.parse_string(file.get_as_text())
file.close()
if not (parsed is Dictionary) or not parsed.has("id") or not parsed.has("start") or not (parsed.get("nodes") is Dictionary):
push_error("Dialog-Datei ist kein gültiger Dialogbaum: %s" % dialogue_path)
return {}
return parsed
## Spielt den Dialogbaum als Coroutine ab: Zeilen über Box und
## Sprechblasen, Entscheidungen über die Auswahl in der Box, Effekte über
## die Options-Tags des ersten Durchlaufs.
##
## Sterben die Sprecher unter dem laufenden Dialog weg (Szenenwechsel —
## dieses Autoload überlebt ihn, die Sprecher nicht), endet der Dialog
## sofort und still: keine weiteren Zeilen in der Box über der neuen
## Szene, keine Abbruch-Zeile ohne Sprecher (CR 25).
func _run_dialogue(data: Dictionary, start_node := "", stop_node := "") -> void:
var nodes: Dictionary = data["nodes"]
var node_id := start_node if start_node != "" else str(data["start"])
if start_node.is_empty():
await _play_time_card(str(data.get("time_card", "")))
while node_id != "" and node_id != stop_node and nodes.has(node_id) and not _is_abort_requested and _are_speakers_alive():
var node: Dictionary = nodes[node_id]
_apply_node_effects(node)
node_started.emit(str(data["id"]), node_id)
var options := _available_options(node.get("options", []))
if options.is_empty() or is_input_locked_node(node):
node_id = await _play_line(node)
else:
node_id = await _play_choice(node, options)
var was_aborted := _is_abort_requested
var is_segment_end := not was_aborted and stop_node != "" and node_id == stop_node
if was_aborted and _are_speakers_alive():
await _play_abort_line()
_end_dialogue(str(data["id"]), was_aborted, is_segment_end)
## Wacht während eines laufenden Dialogs darüber, dass die Sprecher noch
## existieren. Sterben sie unter dem Dialog weg (Szenenwechsel), wird der
## Abbruch gesetzt und eine offene Antwortauswahl aufgelöst — sonst hinge
## die Coroutine für immer im choose()-Await der Box (CR 25).
func _process(_delta: float) -> void:
if not is_dialogue_active or _are_speakers_alive():
return
_is_abort_requested = true
if _box != null:
_box.force_abort()
## Leben alle registrierten Sprecher-Nodes noch?
func _are_speakers_alive() -> bool:
for speaker in _speakers.values():
if speaker == null or not is_instance_valid(speaker):
return false
return true
## Zeigt die Titelkarte eines Dialogs (`time_card` im Kopf der Datei,
## CR 43): Vollbild, schwarz, der Zeitsprung als Text — sie ersetzt den
## abgeschafften Erzähler bei Zeitsprüngen (CR 37). Läuft vor dem ersten
## Knoten, blendet auf, hält TIME_CARD_SECONDS und blendet ab;
## confirm/interact/cancel überspringt sie sofort. Ohne `time_card`
## passiert nichts.
func _play_time_card(text: String) -> void:
if text.is_empty():
return
var layer := CanvasLayer.new()
layer.layer = 6
var overlay := ColorRect.new()
overlay.set_anchors_preset(Control.PRESET_FULL_RECT)
overlay.color = Color(0.02, 0.02, 0.03, 1.0)
overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
var label := Label.new()
label.set_anchors_preset(Control.PRESET_FULL_RECT)
label.text = text
label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER
label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART
label.add_theme_font_size_override("font_size", 44)
label.add_theme_color_override("font_color", Color(0.94, 0.92, 0.86))
overlay.add_child(label)
layer.add_child(overlay)
add_child(layer)
overlay.modulate.a = 0.0
_is_skip_requested = false
await _fade_time_card(overlay, 1.0, TIME_CARD_FADE)
var held := 0.0
while held < TIME_CARD_SECONDS and not _is_skip_requested and not _is_abort_requested:
await get_tree().process_frame
held += get_process_delta_time()
await _fade_time_card(overlay, 0.0, TIME_CARD_FADE)
_is_skip_requested = false
layer.queue_free()
## Blendet die Titelkarte weich auf oder ab; ein Skip-Wunsch kürzt das
## Blenden ab, damit die Karte sofort weiterspringt.
func _fade_time_card(overlay: ColorRect, target_alpha: float, seconds: float) -> void:
var elapsed := 0.0
var start_alpha: float = overlay.modulate.a
while elapsed < seconds and not _is_skip_requested and not _is_abort_requested:
await get_tree().process_frame
elapsed += get_process_delta_time()
overlay.modulate.a = lerpf(start_alpha, target_alpha, minf(elapsed / seconds, 1.0))
overlay.modulate.a = target_alpha
## Filtert die Optionen eines Knotens nach dem `requires_flag`-Tag
## (CR 43): Eine Option mit diesem Tag erscheint NUR, wenn das genannte
## Story-Flag gesetzt und wahr ist — sonst wird sie ausgeblendet, nicht
## ausgegraut. Ohne das Tag ist eine Option immer sichtbar.
##
## Bleibt dabei keine Option übrig, behandelt _run_dialogue den Knoten
## wie eine reine Zeile und folgt seinem "next" — so bleibt ein Baum
## spielbar, dessen Varianten alle an Flags hängen (z. B.
## akt2_k4_erwachen/t_variante), statt in einer leeren Auswahl zu hängen.
func _available_options(options: Array) -> Array:
var available: Array = []
for option in options:
if not (option is Dictionary):
continue
var flag_name := str(option.get("requires_flag", ""))
if not flag_name.is_empty() and not bool(GameState.get_story_flag(flag_name, false)):
continue
available.append(option)
return available
## Liefert den anzuzeigenden Text eines Knotens: Standard ist "text"
## (Fade-to-Black-Variante); trägt der Knoten ein optionales Feld
## "explicit_text" UND ist der Mature-Toggle aktiv, wird stattdessen die
## explizite Variante gezeigt (Romantik-Weiche, SPEC Abschnitt 6 — die
## expliziten Texte pflegt ausschließlich der Nutzer in den
## Dialog-Dateien, dieses Projekt liefert nur das Format).
##
## `signet_lines` (CR 43) schlägt beides: Trägt der Knoten diese Tabelle,
## wird die Zeile zu Tyrveils gewürfelter Erstkraft gewählt (Schlüssel =
## Signet-ID, Rückfall auf den Schlüssel "default"). Erst wenn beides
## fehlt, gilt der normale Knotentext.
func _node_text(node: Dictionary) -> String:
var signet_line := _signet_line(node)
if not signet_line.is_empty():
return signet_line
if MatureContentGate.is_explicit_enabled and node.has("explicit_text"):
return str(node["explicit_text"])
return str(node.get("text", ""))
## Wählt aus der `signet_lines`-Tabelle eines Knotens die Zeile zu
## Tyrveils gewürfelter erster Siegelkraft (CR 43). Leerer String, wenn
## der Knoten keine Tabelle trägt oder weder die Signet-ID noch ein
## "default"-Eintrag darin vorkommt.
func _signet_line(node: Dictionary) -> String:
if not (node.get("signet_lines") is Dictionary):
return ""
var lines: Dictionary = node["signet_lines"]
var signet_id := str(SignetSystem.get_first_signet().get("id", ""))
if not signet_id.is_empty() and lines.has(signet_id):
return str(lines[signet_id])
return str(lines.get("default", ""))
## Zeigt eine Zeile ohne Optionen in Box und Sprechblase; die Blase (oder
## ein Fallback-Timer) bestimmt die Anzeigedauer. Liefert die ID des
## Folge-Knotens.
func _play_line(node: Dictionary) -> String:
var speaker_id := str(node.get("speaker", ""))
var text := _node_text(node)
_is_input_locked = is_input_locked_node(node)
_get_box().show_line(_display_name(speaker_id), text)
var bubble := _bubble_for(speaker_id)
if bubble != null:
bubble.show_line(text)
await _wait_for_line(bubble)
if _is_input_locked:
await get_tree().create_timer(INPUT_LOCK_HOLD).timeout
_is_input_locked = false
return _next_id(node)
## Trägt der Knoten das `no_input`-Tag (CR 44)? Öffentlich, damit Szenen und
## Sonden das Fenster erkennen können.
func is_input_locked_node(node: Dictionary) -> bool:
return bool(node.get("no_input", false))
## Meldet, ob gerade ein gesperrter Knoten läuft (jede Eingabe wirkungslos).
func is_input_locked() -> bool:
return _is_input_locked
## Wartet das Ende einer Zeile ab (Sprechblasen-Dauer oder Fallback-Timer)
## und bricht früh ab, sobald ein Dialog-Abbruch oder ein Zeilen-Skip
## (confirm/interact) angefordert wurde.
func _wait_for_line(bubble: Node) -> void:
_is_skip_requested = false
if bubble != null:
while is_instance_valid(bubble) and bubble.visible and not _is_abort_requested and not _is_skip_requested:
await get_tree().process_frame
if is_instance_valid(bubble) and (_is_abort_requested or _is_skip_requested):
bubble.hide_bubble()
else:
var timer := get_tree().create_timer(FALLBACK_LINE_SECONDS)
while timer.time_left > 0.0 and not _is_abort_requested and not _is_skip_requested:
await get_tree().process_frame
_is_skip_requested = false
## Zeigt eine Zeile mit Antwortoptionen in Box (mit Auswahl) und
## Sprechblase (sticky), wendet beim ersten Durchlauf die Tags der
## gewählten Option an, spielt die Antwort über Tyrveils Blase und liefert
## die ID des Folge-Knotens.
func _play_choice(node: Dictionary, options: Array) -> String:
var speaker_id := str(node.get("speaker", ""))
var text := _node_text(node)
_get_box().show_line(_display_name(speaker_id), text)
var bubble := _bubble_for(speaker_id)
if bubble != null:
bubble.show_line(text, true)
var option_texts: Array[String] = []
for option in options:
option_texts.append(str(option.get("text", "")))
var index: int = await _get_box().choose(option_texts)
if bubble != null:
bubble.hide_bubble()
if index < 0:
_is_abort_requested = true
return ""
var option: Dictionary = options[clampi(index, 0, options.size() - 1)]
_apply_option_effects(option)
var answer := str(option.get("text", ""))
_get_box().show_line(_display_name(PLAYER_SPEAKER_ID), answer)
var player_bubble := _bubble_for(PLAYER_SPEAKER_ID)
if player_bubble != null:
player_bubble.show_line(answer)
await _wait_for_line(player_bubble)
return _resolve_next(option)
## Löst den Folge-Knoten einer Option auf: Trägt sie einen verdeckten
## Erfolgs-Check, entscheidet ein versteckter Wurf zwischen success_next
## und fail_next; sonst gilt next.
func _resolve_next(option: Dictionary) -> String:
if not (option.get("check") is Dictionary):
return _next_id(option)
var check: Dictionary = option["check"]
if randf() * 100.0 < compute_check_chance(check):
return str(check.get("success_next", ""))
return str(check.get("fail_next", ""))
## Berechnet die verdeckte Erfolgs-Chance eines Options-Checks:
## base plus voller Wert des angegebenen Stats (strength/agility/
## intellect) plus halber Beziehungswert (relationship: NPC-ID),
## geklemmt auf 5–95 % — es bleibt immer Restrisiko und Resthoffnung.
func compute_check_chance(check: Dictionary) -> int:
var chance := int(check.get("base", 50))
match str(check.get("stat", "")):
"strength":
chance += GameState.strength
"agility":
chance += GameState.agility
"intellect":
chance += GameState.intellect
var npc_id := str(check.get("relationship", ""))
if not npc_id.is_empty():
chance += RelationshipSystem.get_relationship(npc_id) / 2
return clampi(chance, 5, 95)
## Wendet die `story_flag` eines KNOTENS an, sobald er gespielt wird (CR 49).
##
## Die Autorendateien setzen Flags seit Akt 2 an beidem — an Optionen UND an
## Knoten —, angewendet wurden bisher aber nur die der gewählten Option. Damit
## blieben 112 Flags in 56 Dateien still liegen: Kapitel-Abschlüsse wie
## `akt2_abgeschlossen`, `wren_ungebunden` (das Abnahmekriterium von CR 36) und
## Vorgeschichten, auf die `requires_flag`-Optionen später prüfen — die
## erschienen dann nie, ohne Fehlermeldung.
##
## Gilt derselbe Erster-Durchlauf-Schutz wie bei den Options-Effekten: Ein
## zweiter Durchlauf desselben Dialogs setzt nichts erneut, sonst würde ein
## Wiederholen Werte doppeln oder zurücksetzen. Läuft VOR `node_started`, damit
## Zuhörer (z. B. FallState) den Knoten schon mit gesetzten Flags sehen.
func _apply_node_effects(node: Dictionary) -> void:
if not _is_effect_pass:
return
var flag_changes: Dictionary = node.get("story_flag", {})
for flag_name in flag_changes:
GameState.set_story_flag(str(flag_name), flag_changes[flag_name])
_has_applied_effects = true
## Wendet die Effekt-Tags einer Option an — nur beim ersten Durchlauf des
## Dialogs: blade_heart verschiebt die Klinge-↔-Herz-Achse, relationship
## verschiebt Beziehungswerte pro NPC.
func _apply_option_effects(option: Dictionary) -> void:
if not _is_effect_pass:
return
var tone_shift := int(option.get("blade_heart", 0))
if tone_shift != 0:
GameState.shift_blade_heart_tone(tone_shift)
_has_applied_effects = true
var bond_shift := int(option.get("bond", 0))
if bond_shift != 0:
DragonBondSystem.adjust_bond(bond_shift)
_has_applied_effects = true
var relationship_shifts: Dictionary = option.get("relationship", {})
for npc_id in relationship_shifts:
RelationshipSystem.adjust_relationship(str(npc_id), int(relationship_shifts[npc_id]))
_has_applied_effects = true
var flag_changes: Dictionary = option.get("story_flag", {})
for flag_name in flag_changes:
GameState.set_story_flag(str(flag_name), flag_changes[flag_name])
_has_applied_effects = true
var standing_shifts: Dictionary = option.get("faction_standing", {})
for faction_id in standing_shifts:
FactionSystem.adjust_standing(str(faction_id), int(standing_shifts[faction_id]))
_has_applied_effects = true
## Spielt eine zufällig gewählte Abbruch-Zeile Tyrveils, damit der
## Abbruch dem Gegenüber angesagt wird, bevor der Dialog endet.
func _play_abort_line() -> void:
_is_abort_requested = false
var line := str(_abort_lines.pick_random())
_get_box().show_line(_display_name(PLAYER_SPEAKER_ID), line)
var player_bubble := _bubble_for(PLAYER_SPEAKER_ID)
if player_bubble != null:
player_bubble.show_line(line)
await _wait_for_line(player_bubble)
## Beendet den Dialog und gibt Box und Sprecher-Referenzen frei. Als
## geführt markiert wird er bei regulärem Ende immer, bei Abbruch nur,
## wenn in diesem Durchlauf bereits Effekte angewendet wurden (verhindert
## Werte-Farming, lässt aber den Erst-Durchlauf-Effekt bestehen).
##
## **Ein Segment, das an seinem `stop_node` endet, ist kein Ende** (CR 48):
## Der Dialog geht im nächsten Segment weiter. Würde er hier schon als
## geführt markiert, liefen alle folgenden Segmente ohne Effekte — Story-
## Flags und Klinge/Herz-Verschiebungen fielen still weg (Akt 3 K3: vom
## Anflug bis `sie_kommt`).
func _end_dialogue(dialogue_id: String, was_aborted := false, is_segment_end := false) -> void:
_is_input_locked = false
if not is_segment_end and (not was_aborted or _has_applied_effects):
GameState.mark_dialogue_completed(dialogue_id)
_get_box().hide_box()
is_dialogue_active = false
_speakers.clear()
_speaker_names.clear()
dialogue_finished.emit(dialogue_id)
## Liefert die Sprechblase (Kind "SpeechBubble") eines Sprechers, null mit
## Warnung, wenn Sprecher oder Blase fehlen.
func _bubble_for(speaker_id: String) -> Node:
var speaker: Node = _speakers.get(speaker_id)
if speaker == null:
push_warning("Kein Sprecher-Node für ID '%s' registriert." % speaker_id)
return null
var bubble := speaker.get_node_or_null("SpeechBubble")
if bubble == null:
push_warning("Sprecher '%s' hat keine SpeechBubble." % speaker_id)
return bubble
## Liefert den Anzeigenamen eines Sprechers aus der speakers-Map der
## Dialog-Datei, sonst die großgeschriebene Sprecher-ID.
func _display_name(speaker_id: String) -> String:
return str(_speaker_names.get(speaker_id, speaker_id.capitalize()))
## Liefert die ID des Folge-Knotens aus einem Knoten oder einer Option;
## leerer String beendet den Dialog (auch bei JSON-null).
func _next_id(source: Dictionary) -> String:
var next: Variant = source.get("next")
return next if next is String else ""
## Instanziiert die Dialog-Box beim ersten Bedarf.
func _get_box() -> CanvasLayer:
if _box == null:
_box = BOX_SCENE.instantiate()
add_child(_box)
return _box