Vier Tags, die die Dialogdateien seit Akt 2 durchgaengig benutzen, wurden vom DialogueSystem stillschweigend ignoriert. Jetzt wirken alle vier. - requires_flag (13x): _available_options() blendet Optionen ohne gesetztes Story-Flag AUS (kein Ausgrauen). Bleibt keine Option uebrig, laeuft der Knoten als reine Zeile weiter und folgt seinem next — sonst hinge akt2_k4_erwachen/t_variante (beide Varianten flag-gebunden) in einer leeren Auswahl. - bond (64x): neu GameState.bond_level (-100..100, Signal, save-persistent) plus Fassade DragonBondSystem.get_bond()/adjust_bond()/set_bond() analog zu RelationshipSystem. Die 64 Werte landen messbar im Spielstand. - time_card (15 Dateien): Vollbild-Titelkarte vor dem ersten Knoten, weiches Blenden, ueberspringbar — ersetzt den Erzaehler bei Zeitspruengen (CR 37). - signet_lines (3x): _node_text() waehlt die Zeile zu Tyrveils gewuerfelter Erstkraft, Rueckfall auf "default" (greift in CR 35). - _regie/_entwurf bleiben unimplementiert; automatisierter Test prueft, dass kein Spiel-Skript diese Felder liest. Datenaenderung (die einzigen zwei): Die zwei echten Options-Faelle aus der CR-Tabelle haben das Tag bekommen — akt3_k3_smaladh "Der Brief ist weg." (coran_brief) und akt3_k5_abschied "Frag mich naechste Woche noch mal." (resson_rowdy). Die anderen vier CR-Stellen sind KEINE Optionen, sondern wortlose Knoten mit bedingter _regie-Inszenierung — sie sprechen heute nichts Falsches und gehoeren in den Szenen-Bau. Details in DONE. Verifikation: Headless-Probe 19/19 (alle vier Tags, Klemmung, Save- Persistenz, Skip, Leer-Auswahl), Realdaten-Probe 10/10 (beide Akt-3-Gates, Zaehlungen 15/15/64, alle 107 Dialogdateien parsen), Boot-Check 7 Szenen 0 Fehler. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
476 lines
20 KiB
GDScript
476 lines
20 KiB
GDScript
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".
|
||
##
|
||
## `_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 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 _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
|
||
_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 _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():
|
||
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)
|
||
_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)
|
||
return _next_id(node)
|
||
|
||
|
||
## 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:
|
||
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
|