class_name FallAtmosphaere extends Node ## Lichtstimmung und Asche zum Fall in Akt 3 K3 (CR 48). ## ## Die vier `FallState`-Phasen brauchen laut Mikes Raumkonzept **keine eigene ## Geometrie** — eine Karte, zwei Zustände, und die Phasen unterscheiden sich ## nur in Atmosphäre. Genau die hängt hier dran: Sonne, Umgebungslicht, Nebel ## und ein Ascheschleier kippen mit der Oberflächen-Erosion mit, bis am Ende ## nichts mehr auf dem Bild ist außer dem Dorf. ## ## **Der Übergang von Phase 1 zu Phase 2 hat keine Ansage** (CR 45): Die Werte ## gleiten ineinander, sie springen nie. `gefecht` liegt bewusst nah an `aus`, ## damit sich die erste Phase wie ein normales Gefecht anfühlt — wer dort ## etwas aufblitzen sieht, weiß Bescheid, bevor er es soll. ## ## Während `EROSION` wird zwischen `kostenlos` und `erosion_ende` geblendet, ## gesteuert von `FallState.erosion()`. Das läuft über dieselbe Zeit wie die ## HUD-Erosion, damit Bild und Oberfläche gemeinsam leer werden. ## ## **Zum Einhängen:** Die Szene braucht nichts vorzubereiten. Fehlen Sonne, ## WorldEnvironment oder Ascheschleier, sucht die Komponente sie im Elternbaum ## und legt an, was nicht da ist. Wer eigene Knoten setzen will, füllt die ## Export-Pfade. const DATEI := "res://data/story/fall_atmosphaere.json" const STANDARD_TEMPO := 0.4 const ASCHE_LEBEN := 6.0 const ASCHE_BOX := Vector3(60, 26, 60) @export var sonne_pfad: NodePath @export var umgebung_pfad: NodePath @export var asche_pfad: NodePath var _phasen: Dictionary = {} var _tempo := STANDARD_TEMPO var _aktuell: Dictionary = {} var _sonne: DirectionalLight3D var _umgebung: WorldEnvironment var _asche: GPUParticles3D var _asche_max := 1 ## Lädt die Stimmungstabelle, sucht oder baut die Knoten und setzt den ## Ausgangszustand. func _ready() -> void: var daten := _lade() _phasen = daten.get("phasen", {}) _tempo = float(daten.get("uebergang_tempo", STANDARD_TEMPO)) _sonne = _finde(sonne_pfad, "DirectionalLight3D") as DirectionalLight3D _umgebung = _finde(umgebung_pfad, "WorldEnvironment") as WorldEnvironment _asche = _finde(asche_pfad, "GPUParticles3D") as GPUParticles3D if _asche == null: _asche = _baue_asche() _aktuell = _ziel().duplicate() _wende_an() FallState.phase_changed.connect(_on_phase) ## Zieht die aktuellen Werte weich auf das Ziel der laufenden Phase. func _process(delta: float) -> void: var ziel := _ziel() var fertig := true for schluessel in ziel: var alt: Variant = _aktuell.get(schluessel) var neu: Variant = ziel[schluessel] if alt is float and neu is float: var wert: float = lerpf(alt, neu, minf(_tempo * delta * 4.0, 1.0)) if absf(wert - neu) > 0.0005: fertig = false _aktuell[schluessel] = wert elif alt is Color and neu is Color: _aktuell[schluessel] = (alt as Color).lerp(neu, minf(_tempo * delta * 4.0, 1.0)) if not (_aktuell[schluessel] as Color).is_equal_approx(neu): fertig = false else: _aktuell[schluessel] = neu _wende_an() if fertig and not FallState.is_eroding(): set_process(FallState.is_active()) ## Hält die Komponente wach, sobald sich die Phase ändert. func _on_phase(_phase: int) -> void: set_process(true) ## Der Zielzustand für die laufende Phase. Während EROSION wird zwischen ## `kostenlos` und `erosion_ende` geblendet — gesteuert vom Erosions- ## Fortschritt, damit die Stimmung mit der Oberfläche mitkippt. func _ziel() -> Dictionary: match FallState.phase: FallState.Phase.GEFECHT: return _werte("gefecht") FallState.Phase.KOSTENLOS: return _werte("kostenlos") FallState.Phase.EROSION: return _mische(_werte("kostenlos"), _werte("erosion_ende"), FallState.erosion()) _: return _werte("aus") ## Schreibt die aktuellen Werte in Licht, Umgebung und Ascheschleier. func _wende_an() -> void: if _sonne != null and is_instance_valid(_sonne): _sonne.light_energy = float(_aktuell.get("sonne", 1.0)) _sonne.light_color = _aktuell.get("sonne_farbe", Color.WHITE) if _umgebung != null and is_instance_valid(_umgebung) and _umgebung.environment != null: var umgebung := _umgebung.environment umgebung.ambient_light_energy = float(_aktuell.get("umgebung", 1.0)) var dichte := float(_aktuell.get("nebel", 0.0)) umgebung.fog_enabled = dichte > 0.0005 umgebung.fog_density = dichte umgebung.fog_light_color = _aktuell.get("nebel_farbe", Color.GRAY) if _asche != null and is_instance_valid(_asche): var menge := int(round(float(_aktuell.get("asche", 0.0)))) _asche.emitting = menge > 0 _asche.amount_ratio = clampf(float(menge) / float(_asche_max), 0.0, 1.0) ## Liest eine Phase aus der Tabelle in ein Wertepaket. func _werte(name: String) -> Dictionary: var eintrag: Dictionary = _phasen.get(name, {}) return { "sonne": float(eintrag.get("sonne", 1.0)), "sonne_farbe": _als_farbe(eintrag.get("sonne_farbe", [1, 1, 1])), "umgebung": float(eintrag.get("umgebung", 1.0)), "nebel": float(eintrag.get("nebel", 0.0)), "nebel_farbe": _als_farbe(eintrag.get("nebel_farbe", [0.5, 0.5, 0.5])), "asche": float(eintrag.get("asche", 0)), } ## Blendet zwei Wertepakete ineinander. func _mische(von: Dictionary, nach: Dictionary, anteil: float) -> Dictionary: var ergebnis: Dictionary = {} var t := clampf(anteil, 0.0, 1.0) for schluessel in von: var a: Variant = von[schluessel] var b: Variant = nach.get(schluessel, a) if a is float and b is float: ergebnis[schluessel] = lerpf(a, b, t) elif a is Color and b is Color: ergebnis[schluessel] = (a as Color).lerp(b, t) else: ergebnis[schluessel] = b return ergebnis ## Baut den Ascheschleier, falls die Szene keinen mitbringt — so muss Mikes ## Dorf nichts vorbereiten. ## ## Das Einhängen läuft deferred: Diese Komponente ist `_ready`, während der ## Elternknoten noch seine eigenen Kinder aufbaut, und ein direktes ## `add_child` scheitert dort still. func _baue_asche() -> GPUParticles3D: var partikel := GPUParticles3D.new() partikel.name = "Asche" var material := ParticleProcessMaterial.new() material.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_BOX material.emission_box_extents = ASCHE_BOX * 0.5 material.gravity = Vector3(0, -0.6, 0) material.initial_velocity_min = 0.2 material.initial_velocity_max = 1.1 material.scale_min = 0.03 material.scale_max = 0.12 material.color = Color(0.45, 0.42, 0.40, 0.75) partikel.process_material = material var mesh := QuadMesh.new() mesh.size = Vector2(0.12, 0.12) var flaeche := StandardMaterial3D.new() flaeche.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA flaeche.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED flaeche.billboard_mode = BaseMaterial3D.BILLBOARD_PARTICLES flaeche.albedo_color = Color(0.5, 0.47, 0.45, 0.8) mesh.material = flaeche partikel.draw_pass_1 = mesh _asche_max = int(_werte("erosion_ende").get("asche", 1)) partikel.amount = maxi(_asche_max, 1) partikel.lifetime = ASCHE_LEBEN partikel.position = Vector3(0, ASCHE_BOX.y * 0.4, 0) partikel.emitting = false _eltern().add_child.call_deferred(partikel) return partikel ## Sucht einen Knoten über den Export-Pfad, sonst per Typ im Elternbaum. func _finde(pfad: NodePath, typ: String) -> Node: if not pfad.is_empty(): var gesetzt := get_node_or_null(pfad) if gesetzt != null: return gesetzt return _suche(_eltern(), typ) ## Tiefensuche nach dem ersten Knoten eines Typs. func _suche(wurzel: Node, typ: String) -> Node: for kind in wurzel.get_children(): if kind.is_class(typ): return kind var treffer := _suche(kind, typ) if treffer != null: return treffer return null ## Der Knoten, unter dem gesucht und gebaut wird. func _eltern() -> Node: var eltern := get_parent() return eltern if eltern != null else self ## Wandelt einen Farbeintrag aus der Tabelle. func _als_farbe(werte: Variant) -> Color: if not (werte is Array) or werte.size() < 3: return Color.WHITE return Color(float(werte[0]), float(werte[1]), float(werte[2])) ## Die aktuell gesetzten Werte (für Sonden). func werte() -> Dictionary: return _aktuell.duplicate() ## Liest die Stimmungstabelle; leere Tabelle bei Fehlern. func _lade() -> Dictionary: if not FileAccess.file_exists(DATEI): push_error("Fall-Atmosphäre nicht lesbar: %s" % DATEI) return {} var geparst: Variant = JSON.parse_string(FileAccess.get_file_as_string(DATEI)) if not (geparst is Dictionary): push_error("Fall-Atmosphäre ist ungültig: %s" % DATEI) return {} return geparst