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>
233 lines
8.2 KiB
GDScript
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
|