extends Node ## Ambient-Gespräche zwischen NPCs (Phase 2c), Szenen-lokaler Manager. ## ## Prüft periodisch alle NPC-Paare (Gruppe "npc"): Sind sich zwei ## verfügbare NPCs nahe genug und existiert für das Paar ein Austausch in ## data/dialogue/ambient_lines.json, startet er mit exchange_chance einen ## zufällig gewählten kurzen Wortwechsel — über die Sprechblasen, nicht ## über die Chatbox: Die Box ist das Spieler-Dialog-UI mit ## Auswahl-Semantik und würde Spieler-Beteiligung suggerieren; ## Ambient-Zeilen sind Welt-Ambiente ohne Auswahl und gehören räumlich zu ## den Figuren. Ambient-Gespräche verändern keine Werte und sperren den ## Spieler nicht. Spricht der Spieler einen beteiligten NPC an, bricht ## der Austausch sofort ab; NPCs im Spieler-Dialog werden nie ## Ambient-Partner. Pro Paar gilt ein Cooldown. const LINES_PATH := "res://data/dialogue/ambient_lines.json" const CHECK_INTERVAL := 3.0 const PROXIMITY := 4.0 const PAIR_COOLDOWN_MS := 25000 @export var exchange_chance := 0.35 var _exchanges: Array = [] var _cooldowns: Dictionary = {} var _check_remaining := CHECK_INTERVAL var _active_npcs: Array = [] var _is_exchange_running := false var _is_exchange_aborted := false ## Lädt die Austausch-Daten und lauscht auf Spieler-Dialog-Starts. func _ready() -> void: _exchanges = _load_exchanges() DialogueSystem.dialogue_started.connect(_on_player_dialogue_started) ## Prüft im Intervall, ob ein Ambient-Austausch starten kann. func _process(delta: float) -> void: if _is_exchange_running or _exchanges.is_empty(): return _check_remaining -= delta if _check_remaining > 0.0: return _check_remaining = CHECK_INTERVAL _try_start_exchange() ## Liest und validiert die Ambient-Datei; leeres Array bei Fehlern. func _load_exchanges() -> Array: var file := FileAccess.open(LINES_PATH, FileAccess.READ) if file == null: push_error("Ambient-Datei nicht lesbar: %s (%s)" % [LINES_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.get("exchanges") is Array): push_error("Ambient-Datei ist keine gültige Austausch-Liste: %s" % LINES_PATH) return [] return parsed["exchanges"] ## Sucht das erste verfügbare, nahe NPC-Paar mit passendem Austausch und ## würfelt den Start über exchange_chance aus. func _try_start_exchange() -> void: var npcs := get_tree().get_nodes_in_group("npc") for i in npcs.size(): for j in range(i + 1, npcs.size()): var npc_a: Node3D = npcs[i] var npc_b: Node3D = npcs[j] if not (npc_a.can_start_ambient() and npc_b.can_start_ambient()): continue if npc_a.global_position.distance_to(npc_b.global_position) > PROXIMITY: continue if _is_pair_on_cooldown(npc_a.npc_id, npc_b.npc_id): continue var exchange := _pick_exchange(npc_a.npc_id, npc_b.npc_id) if exchange.is_empty(): continue if randf() > exchange_chance: continue _run_exchange(npc_a, npc_b, exchange) return ## Wählt zufällig einen Austausch für das Paar (Reihenfolge egal), ## leeres Dictionary wenn keiner existiert. func _pick_exchange(id_a: String, id_b: String) -> Dictionary: var candidates: Array = [] for exchange in _exchanges: var pair: Array = exchange.get("npcs", []) if pair.size() != 2: continue if (pair[0] == id_a and pair[1] == id_b) or (pair[0] == id_b and pair[1] == id_a): candidates.append(exchange) if candidates.is_empty(): return {} return candidates.pick_random() ## Spielt einen Austausch als Coroutine über die Sprechblasen der beiden ## NPCs ab; ein Abbruch (Spieler-Interaktion) beendet ihn sofort sauber. func _run_exchange(npc_a: Node3D, npc_b: Node3D, exchange: Dictionary) -> void: _is_exchange_running = true _is_exchange_aborted = false _active_npcs = [npc_a, npc_b] npc_a.begin_ambient(npc_b.global_position) npc_b.begin_ambient(npc_a.global_position) var by_id := { npc_a.npc_id: npc_a, npc_b.npc_id: npc_b } for line in exchange.get("lines", []): if _is_exchange_aborted: break var speaker: Node3D = by_id.get(str(line.get("speaker", ""))) if speaker == null: continue var bubble: Node = speaker.get_node_or_null("SpeechBubble") if bubble == null: continue bubble.show_line(str(line.get("text", ""))) await _wait_for_bubble(bubble) for npc in _active_npcs: npc.end_ambient() _set_pair_cooldown(npc_a.npc_id, npc_b.npc_id) _active_npcs = [] _is_exchange_running = false ## Wartet das Zeilenende einer Sprechblase ab, bricht bei Abbruch früh ab. func _wait_for_bubble(bubble: Node) -> void: while bubble.visible and not _is_exchange_aborted: await get_tree().process_frame if _is_exchange_aborted: bubble.hide_bubble() ## Bricht den laufenden Austausch ab, wenn der Spieler einen der ## beteiligten NPCs anspricht. func _on_player_dialogue_started(_dialogue_id: String) -> void: if not _is_exchange_running: return for npc in _active_npcs: if DialogueSystem.is_speaker(npc): _abort_exchange() return ## Blendet die Blasen aus und entlässt die NPCs aus dem Ambient-Zustand; ## der NPC im Spieler-Dialog bleibt davon unberührt. func _abort_exchange() -> void: _is_exchange_aborted = true for npc in _active_npcs: var bubble: Node = npc.get_node_or_null("SpeechBubble") if bubble != null: bubble.hide_bubble() npc.end_ambient() ## Gibt zurück, ob das Paar noch im Cooldown steckt. func _is_pair_on_cooldown(id_a: String, id_b: String) -> bool: var key := _pair_key(id_a, id_b) return _cooldowns.has(key) and Time.get_ticks_msec() - _cooldowns[key] < PAIR_COOLDOWN_MS ## Startet den Cooldown für das Paar. func _set_pair_cooldown(id_a: String, id_b: String) -> void: _cooldowns[_pair_key(id_a, id_b)] = Time.get_ticks_msec() ## Liefert einen reihenfolge-unabhängigen Schlüssel für ein NPC-Paar. func _pair_key(id_a: String, id_b: String) -> String: return "%s|%s" % [mini(id_a.hash(), id_b.hash()), maxi(id_a.hash(), id_b.hash())]