windgeschworen/scripts/gameplay/fall_atmosphaere.gd
danny 5b29213cc5 CR 48: Fall-Atmosphaere je FallState-Phase vorbereitet
Mike hat bestaetigt, dass die vier Phasen keine eigene Geometrie brauchen,
nur Lichtstimmung und Partikel, die mit der Oberflaechen-Erosion mitkippen.
Genau das haengt hier dran: Sonne, Umgebungslicht, Nebel und ein
Ascheschleier, gesteuert ueber FallState.

Werte liegen in data/story/fall_atmosphaere.json, also ohne Codeaenderung
tunebar. Waehrend EROSION wird zwischen kostenlos und erosion_ende
geblendet, gesteuert von FallState.erosion() (24 s) — dieselbe Zeitachse wie
die HUD-Erosion, damit Bild und Oberflaeche gemeinsam leer werden.

Zwei Dinge bewusst so gebaut:
- gefecht liegt nah an aus. Die erste Phase soll sich wie ein normales
  Gefecht anfuehlen; wer dort etwas aufblitzen sieht, weiss Bescheid, bevor
  er es soll.
- Die Werte gleiten ineinander, sie springen nie — CR 45 verlangt fuer den
  Uebergang Phase 1 -> 2 ausdruecklich keine Ansage.

Zum Einhaengen muss Mikes Dorf nichts vorbereiten: Fehlen Sonne,
WorldEnvironment oder Ascheschleier, sucht die Komponente sie im Elternbaum
und legt an, was fehlt. Wer eigene Knoten setzen will, fuellt die
Export-Pfade. Platzhalter-Buehne: scenes/akt3/fall_atmosphaere_test.tscn.

Ein Fehler beim Verifizieren gefunden: Der selbst gebaute Ascheschleier
wurde nie eingehaengt — add_child scheitert still, wenn die Komponente
_ready laeuft, waehrend der Elternknoten noch seine Kinder aufbaut. Die
uebrigen Werte sahen dabei voellig normal aus, nur die Asche fehlte. Laeuft
jetzt deferred.

Verifikation, Sonde 18/18 mit Kontrollen:
- Kontrolle Uebergang: Einen Frame nach dem Phasenwechsel ist der Wert
  nachweislich noch nicht am Ziel, hat sich aber schon bewegt — es gleitet,
  es springt nicht.
- gefecht unterscheidet sich vom Normalbild um weniger als 0.15
  Lichtenergie; das Erosionsende dagegen um mehr als 0.6.
- Erosionsende: Sonne fast aus, dichtester Nebel, Asche am Maximum — und
  das Licht ist auch wirklich am Knoten gesetzt, nicht nur gerechnet.
- Nach Imogens Ankunft (FallState zurueck auf AUS) kehrt das Bild zurueck.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-12 14:21:38 +02:00

233 lines
8.2 KiB
GDScript

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