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>
This commit is contained in:
parent
2087c8c3ab
commit
5b29213cc5
4 changed files with 308 additions and 0 deletions
41
data/story/fall_atmosphaere.json
Normal file
41
data/story/fall_atmosphaere.json
Normal file
|
|
@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
33
scenes/akt3/fall_atmosphaere_test.tscn
Normal file
33
scenes/akt3/fall_atmosphaere_test.tscn
Normal file
|
|
@ -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")
|
||||
233
scripts/gameplay/fall_atmosphaere.gd
Normal file
233
scripts/gameplay/fall_atmosphaere.gd
Normal file
|
|
@ -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
|
||||
1
scripts/gameplay/fall_atmosphaere.gd.uid
Normal file
1
scripts/gameplay/fall_atmosphaere.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://dwpgodsd3b7np
|
||||
Loading…
Add table
Add a link
Reference in a new issue