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). ## ## `_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) 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] 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 if was_aborted and _are_speakers_alive(): await _play_abort_line() _end_dialogue(str(data["id"]), was_aborted) ## 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 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). func _end_dialogue(dialogue_id: String, was_aborted := false) -> void: _is_input_locked = false if 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