diff --git a/data/story/fall_atmosphaere.json b/data/story/fall_atmosphaere.json new file mode 100644 index 0000000..c2a91c8 --- /dev/null +++ b/data/story/fall_atmosphaere.json @@ -0,0 +1,41 @@ +{ + "_entwurf": "CR 48 — Lichtstimmung und Partikel je FallState-Phase fuer das Dorf in Akt 3 K3. Mike baut die Geometrie (eine Karte, zwei Zustaende); die Phasen brauchen laut ihm KEINE eigene Geometrie, nur Atmosphaere, die mit der Oberflaechen-Erosion mitkippt. Genau das steht hier. — WICHTIG: Der Uebergang von Phase 1 zu Phase 2 hat laut CR 45 keine Ansage. Die Werte gleiten deshalb ineinander (uebergang_tempo), sie springen nie. gefecht liegt bewusst nah an aus: Die erste Phase soll sich wie ein normales Gefecht anfuehlen. — Waehrend EROSION wird zwischen kostenlos und erosion_ende geblendet, gesteuert von FallState.erosion() (24 s). Das deckt sich mit der HUD-Erosion (4 Anzeigen x 2 s Blende + 3 s Pause), damit Bild und Oberflaeche gemeinsam leer werden.", + "uebergang_tempo": 0.4, + "phasen": { + "aus": { + "sonne": 1.0, + "sonne_farbe": [1.0, 0.97, 0.92], + "umgebung": 1.0, + "nebel": 0.0, + "nebel_farbe": [0.62, 0.63, 0.66], + "asche": 0 + }, + "gefecht": { + "_hinweis": "Fast unveraendert — ein echtes Gefecht mit echten Regeln. Nur ein Hauch Staub, nichts, was etwas ankuendigt.", + "sonne": 0.92, + "sonne_farbe": [1.0, 0.94, 0.86], + "umgebung": 0.9, + "nebel": 0.004, + "nebel_farbe": [0.60, 0.58, 0.56], + "asche": 24 + }, + "kostenlos": { + "_hinweis": "Ab hier kostet nichts mehr, und ab hier beginnt die Oberflaeche zu erodieren. Das Licht faengt an wegzusacken, Asche steigt.", + "sonne": 0.55, + "sonne_farbe": [0.86, 0.74, 0.62], + "umgebung": 0.55, + "nebel": 0.022, + "nebel_farbe": [0.48, 0.44, 0.42], + "asche": 180 + }, + "erosion_ende": { + "_hinweis": "Der Endpunkt der Erosion: Zuletzt ist nichts mehr auf dem Bild ausser dem Dorf. Sonne fast aus, dichter Ascheschleier.", + "sonne": 0.12, + "sonne_farbe": [0.52, 0.38, 0.32], + "umgebung": 0.18, + "nebel": 0.075, + "nebel_farbe": [0.26, 0.22, 0.21], + "asche": 520 + } + } +} diff --git a/scenes/akt3/fall_atmosphaere_test.tscn b/scenes/akt3/fall_atmosphaere_test.tscn new file mode 100644 index 0000000..64ab4a6 --- /dev/null +++ b/scenes/akt3/fall_atmosphaere_test.tscn @@ -0,0 +1,33 @@ +[gd_scene load_steps=5 format=3] + +[ext_resource type="Script" path="res://scripts/gameplay/fall_atmosphaere.gd" id="1_atmo"] + +[sub_resource type="ProceduralSkyMaterial" id="Sky_mat"] +sky_horizon_color = Color(0.6, 0.61, 0.63, 1) +ground_horizon_color = Color(0.6, 0.61, 0.63, 1) + +[sub_resource type="Sky" id="Sky"] +sky_material = SubResource("Sky_mat") + +[sub_resource type="Environment" id="Env"] +background_mode = 2 +sky = SubResource("Sky") +ambient_light_source = 3 +ambient_light_energy = 1.0 +tonemap_mode = 2 + +[node name="DorfPlatzhalter" type="Node3D"] + +[node name="WorldEnvironment" type="WorldEnvironment" parent="."] +environment = SubResource("Env") + +[node name="Sun" type="DirectionalLight3D" parent="."] +transform = Transform3D(0.866025, 0.383022, -0.321394, 0, 0.642788, 0.766044, 0.5, -0.663414, 0.55667, 0, 12, 0) +shadow_enabled = true + +[node name="Kamera" type="Camera3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 3, 14) +current = true + +[node name="FallAtmosphaere" type="Node" parent="."] +script = ExtResource("1_atmo") diff --git a/scripts/gameplay/fall_atmosphaere.gd b/scripts/gameplay/fall_atmosphaere.gd new file mode 100644 index 0000000..95cdb6d --- /dev/null +++ b/scripts/gameplay/fall_atmosphaere.gd @@ -0,0 +1,233 @@ +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 diff --git a/scripts/gameplay/fall_atmosphaere.gd.uid b/scripts/gameplay/fall_atmosphaere.gd.uid new file mode 100644 index 0000000..06fc587 --- /dev/null +++ b/scripts/gameplay/fall_atmosphaere.gd.uid @@ -0,0 +1 @@ +uid://dwpgodsd3b7np