Untersuchung: In vier eskalierenden Reproduktions-Aufbauten (headless direkt, Doppel-Trigger im selben Frame, windowed, windowed mit echtem Physik-body_entered und stehender Absage) ueber 175+ Tuerwechsel kein Absturz und kein einziger Fehlertext. Die Verdachtsstelle aus der CR (zone_trigger-await) ist in Godot 4.7 nachweislich still: Coroutinen auf freigegebenen Instanzen brechen stumm ab, gebundene Timer-Signale werden beim Freigeben getrennt, freigegebene Objekte vergleichen sich gleich null. Die gesamte freed-instance-Klasse scheidet als Ursache aus. Symptombild laut Rueckfrage (Fenster minimiert sich, Standbild, wechselnde Tueren) passt zu einem Stall oder Fokus-Verlust jenseits der Skript-Ebene — das laesst sich erst mit einem echten Log belegen. Trotzdem gehaertet, weil beim Suchen zwei echte (stille) Fehler auffielen: zone_trigger stellt das Absage-Label jetzt ueber einen Kind-Timer statt await zurueck — kein Zombie-Rest nach dem Wechsel. Und stirbt die Szene unter einem laufenden Dialog weg (Auto-Start-Szenen wie Appell koennen mit einem Tuertrigger um denselben Frame rasen), endete der Dialog vorher NIE: die Autoload-Coroutine hing fuer immer im choose()-Await und legte die Box ueber die neue Szene. DialogueSystem prueft jetzt pro Frame, ob die Sprecher noch leben, und beendet den Dialog still; die Box kann eine offene Auswahl von aussen aufloesen. Forensik fuer den naechsten Vorfall: Log-Aufbewahrung auf 30 Dateien erhoeht und jeder Tuerwechsel schreibt eine [tuerwechsel]-Zeile ins Log. Beim naechsten Standbild die neueste Datei aus %APPDATA%/Godot/app_userdata/Windgeschworen/logs/ sichern. CR 25 bleibt in CHANGEREQUESTS.md als IN BEOBACHTUNG stehen. Die Autoren-Docs dieser Runde (STIMMEN.md neu, SPEC/CHARACTERS-Anpassungen, CR 25-27) fahren mit diesem Commit ein. Verifiziert mit einer Regressions-Sonde (5/5: Kind-Timer aktiv, Wechsel mit stehender Absage sauber, Dialog endet still bei toten Sprechern, 15 weitere schnelle Wechsel) und einem Boot-Check ueber 13 Szenen; Sonden vor dem Commit geloescht. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
351 lines
14 KiB
GDScript
351 lines
14 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.
|
||
|
||
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."
|
||
|
||
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.
|
||
func start_dialogue(dialogue_path: String, speakers: Dictionary) -> 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
|
||
_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)
|
||
|
||
|
||
## 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) -> void:
|
||
var nodes: Dictionary = data["nodes"]
|
||
var node_id := str(data["start"])
|
||
while node_id != "" and nodes.has(node_id) and not _is_abort_requested and _are_speakers_alive():
|
||
var node: Dictionary = nodes[node_id]
|
||
var options: Array = 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
|
||
|
||
|
||
## 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).
|
||
func _node_text(node: Dictionary) -> String:
|
||
if MatureContentGate.is_explicit_enabled and node.has("explicit_text"):
|
||
return str(node["explicit_text"])
|
||
return str(node.get("text", ""))
|
||
|
||
|
||
## 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 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
|