windgeschworen/scripts/gameplay/flugstrecke.gd
danny def4066044 Flugkamera startet am Reiter, Inszenierung vergisst abgebaute Figuren
Flugstrecke: Die Kamera springt beim Start an den Reiter, statt quer ueber
das Land hinterherzugleiten (Lieferflug: 370 m in der ersten Sekunde).
Inszenierung: Figuren, die mit ihrem Ort abgebaut werden, fliegen aus der
Blickregie (vorher Skriptfehler pro Frame); eine neue Figur unter derselben
Sprecher-ID ersetzt die alte.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:30:06 +02:00

250 lines
8.6 KiB
GDScript

class_name Flugstrecke
extends Node3D
## Inszenierte Flugstrecke auf festem Wegpunkt-Pfad (CR 51).
##
## Grundmechanik für alle vier geplanten Flugsequenzen: **Der Pfad ist fest,
## die Kamera folgt, der Spieler behält Steuerung — aber nur innerhalb der
## Strecke.** Gedacht als Kette von Wegpunkten statt eines Einzel-Schwenks
## (Vorbild: `player.gd::play_camera_pan`).
##
## Ausdrücklich KEIN freies Fliegen und keine offene Welt — das bleibt das
## eigene Paket aus AKT2.md §7 ⑩. Vorwärts kommt man hier nicht durchs
## Steuern, sondern weil die Strecke läuft; steuern kann man **quer dazu**,
## begrenzt durch den `korridor` der Strecke. Wer nichts drückt, fliegt die
## Route trotzdem sauber ab.
##
## Die Strecken stehen in `data/story/flugstrecken.json` (Reihenfolge,
## Ereignisse, Tempo aus Mikes Raumkonzept). Deren Koordinaten sind noch
## Platzhalter, solange die echten Orte gebaut werden — die Mechanik hängt
## nicht daran, nur die Zahlen werden später ersetzt.
##
## Beats hängen an Wegpunkten: Trägt ein Wegpunkt ein `ereignis`, meldet die
## Strecke es beim Passieren über `wegpunkt_erreicht`. So hängt eine Szene
## ihren Greifen-Angriff oder das Encounter an, ohne dass diese Klasse die
## Story kennt.
signal wegpunkt_erreicht(wegpunkt_id: String, ereignis: String)
signal strecke_beendet(strecken_id: String)
const DATEI := "res://data/story/flugstrecken.json"
const STANDARD_TEMPO := 20.0
const STANDARD_SEITE := 6.0
const STANDARD_HOEHE := 4.0
const AUSWEICH_TEMPO := 9.0
const RUECKSTELL_TEMPO := 1.6
const NEIGUNG := 0.5
const KAMERA_ABSTAND := Vector3(0, 3.2, 9.0)
const KAMERA_TEMPO := 4.0
@export var strecken_id := ""
@export var autostart := false
@export var steuerung_erlaubt := true
var laeuft := false
var _strecken: Dictionary = {}
var _strecke: Dictionary = {}
var _kurve: Curve3D
var _wegpunkte: Array = []
var _distanzen: PackedFloat32Array = PackedFloat32Array()
var _naechster := 0
var _weg := 0.0
var _tempo := STANDARD_TEMPO
var _seite := STANDARD_SEITE
var _hoehe := STANDARD_HOEHE
var _versatz := Vector2.ZERO
var _rig: Node3D
var _kamera: Camera3D
## Lädt die Streckentabelle und startet auf Wunsch sofort.
func _ready() -> void:
_strecken = _lade()
_rig = get_node_or_null("Rig") as Node3D
if _rig == null:
_rig = Node3D.new()
_rig.name = "Rig"
add_child(_rig)
_kamera = get_node_or_null("Kamera") as Camera3D
if autostart and not strecken_id.is_empty():
starte(strecken_id)
## Baut die Strecke auf und setzt den Reiter an den ersten Wegpunkt.
## `zweig` wählt einen benannten Unterpfad (z. B. "rueckweg").
func starte(id: String, zweig := "") -> bool:
var strecke: Dictionary = _strecken.get(id, {})
if strecke.is_empty():
push_error("Flugstrecke unbekannt: %s" % id)
return false
if not zweig.is_empty():
var unterpfad: Dictionary = strecke.get(zweig, {})
if unterpfad.is_empty():
push_error("Flugstrecke %s hat keinen Zweig %s" % [id, zweig])
return false
strecke = _verschmelze(strecke, unterpfad)
_strecke = strecke
strecken_id = id
_wegpunkte = strecke.get("wegpunkte", [])
if _wegpunkte.size() < 2:
push_error("Flugstrecke %s braucht mindestens zwei Wegpunkte" % id)
return false
_tempo = float(strecke.get("tempo", STANDARD_TEMPO))
var korridor_daten: Dictionary = strecke.get("korridor", {})
_seite = float(korridor_daten.get("seite", STANDARD_SEITE))
_hoehe = float(korridor_daten.get("hoehe", STANDARD_HOEHE))
_baue_kurve()
_weg = 0.0
_naechster = 1
_versatz = Vector2.ZERO
_setze_rig(0.0)
if _kamera != null:
_kamera.global_position = _rig.global_position + _rig.global_basis * KAMERA_ABSTAND
_kamera.look_at(_rig.global_position, Vector3.UP)
laeuft = true
return true
## Bricht die Strecke ab, ohne sie zu beenden (Szenenwechsel, Abbruch).
func stoppe() -> void:
laeuft = false
## Trägt den Reiter die Strecke entlang, nimmt die Quer-Steuerung entgegen
## und meldet passierte Wegpunkte.
func _process(delta: float) -> void:
if not laeuft or _kurve == null:
return
_lies_steuerung(delta)
_weg = minf(_weg + _tempo * delta, _kurve.get_baked_length())
_setze_rig(_weg)
_pruefe_wegpunkte()
if _weg >= _kurve.get_baked_length():
laeuft = false
strecke_beendet.emit(strecken_id)
## Quer zur Strecke steuern — seitlich und in der Höhe, beides hart auf den
## Korridor begrenzt. Ohne Eingabe zieht es den Reiter sanft auf die Route
## zurück, damit die Strecke die Führung behält.
func _lies_steuerung(delta: float) -> void:
if not steuerung_erlaubt or DialogueSystem.is_dialogue_active:
_versatz = _versatz.move_toward(Vector2.ZERO, RUECKSTELL_TEMPO * delta)
return
var eingabe := Vector2(
Input.get_axis("move_left", "move_right"),
Input.get_axis("move_back", "move_forward"))
if eingabe.is_zero_approx():
_versatz = _versatz.move_toward(Vector2.ZERO, RUECKSTELL_TEMPO * delta)
else:
_versatz += eingabe * AUSWEICH_TEMPO * delta
_versatz.x = clampf(_versatz.x, -_seite, _seite)
_versatz.y = clampf(_versatz.y, -_hoehe, _hoehe)
## Setzt Reiter und Kamera auf die Streckenposition plus Quer-Versatz.
func _setze_rig(weg: float) -> void:
var basis := _kurve.sample_baked(weg)
var blick := _kurve.sample_baked(minf(weg + 1.0, _kurve.get_baked_length()))
var vorwaerts := blick - basis
if vorwaerts.length() < 0.001:
vorwaerts = Vector3.FORWARD
vorwaerts = vorwaerts.normalized()
var quer := vorwaerts.cross(Vector3.UP)
if quer.length() < 0.001:
quer = Vector3.RIGHT
quer = quer.normalized()
_rig.global_position = basis + quer * _versatz.x + Vector3.UP * _versatz.y
_rig.look_at(_rig.global_position + vorwaerts, Vector3.UP)
_rig.rotation.z = -_versatz.x / maxf(_seite, 0.001) * NEIGUNG
if _kamera != null:
var ziel := _rig.global_position + _rig.global_basis * KAMERA_ABSTAND
_kamera.global_position = _kamera.global_position.lerp(ziel, minf(KAMERA_TEMPO * get_process_delta_time(), 1.0))
_kamera.look_at(_rig.global_position, Vector3.UP)
## Meldet jeden Wegpunkt, den der Reiter gerade passiert hat.
func _pruefe_wegpunkte() -> void:
while _naechster < _distanzen.size() and _weg >= _distanzen[_naechster]:
var punkt: Dictionary = _wegpunkte[_naechster]
wegpunkt_erreicht.emit(str(punkt.get("id", "")), str(punkt.get("ereignis", "")))
_naechster += 1
## Baut die Kurve aus den Wegpunkten und merkt sich deren Weglängen.
##
## Die Distanzen werden auf die **gebackene** Kurvenlänge normiert, denn
## genau gegen die läuft `_weg`. Ohne das kann die aufsummierte Polygonlänge
## minimal über der gebackenen liegen — dann wird der letzte Wegpunkt nie
## erreicht und sein Ereignis (`ankunft`, `encounter`) fällt lautlos aus.
func _baue_kurve() -> void:
_kurve = Curve3D.new()
for punkt in _wegpunkte:
_kurve.add_point(_als_vektor(punkt.get("pos", [])))
var roh: Array[float] = [0.0]
var laenge := 0.0
for i in range(1, _kurve.point_count):
laenge += _kurve.get_point_position(i).distance_to(_kurve.get_point_position(i - 1))
roh.append(laenge)
_distanzen = PackedFloat32Array()
var gebacken := _kurve.get_baked_length()
var faktor := (gebacken / laenge) if laenge > 0.0 else 1.0
for i in roh.size():
_distanzen.append(roh[i] * faktor)
if _distanzen.size() > 0:
_distanzen[_distanzen.size() - 1] = gebacken
## Der Reiter-Knoten, den die Strecke bewegt (für Szenen und Sonden).
func rig() -> Node3D:
return _rig
## Zurückgelegter Anteil der Strecke, 0 bis 1.
func fortschritt() -> float:
if _kurve == null or _kurve.get_baked_length() <= 0.0:
return 0.0
return _weg / _kurve.get_baked_length()
## Aktueller Quer-Versatz (x = seitlich, y = Höhe) — für Sonden.
func versatz() -> Vector2:
return _versatz
## Die Grenzen des Korridors dieser Strecke.
func korridor() -> Vector2:
return Vector2(_seite, _hoehe)
## Liefert die geladene Streckentabelle (für Sonden und Werkzeuge).
func strecken() -> Dictionary:
return _strecken
## Legt einen Zweig über die Hauptstrecke (Tempo und Korridor erben, wenn
## der Zweig nichts eigenes sagt).
func _verschmelze(basis: Dictionary, zweig: Dictionary) -> Dictionary:
var ergebnis := basis.duplicate()
for schluessel in zweig:
ergebnis[schluessel] = zweig[schluessel]
return ergebnis
## Wandelt einen Wegpunkt-Eintrag in einen Vektor.
func _als_vektor(werte: Variant) -> Vector3:
if not (werte is Array) or werte.size() < 3:
return Vector3.ZERO
return Vector3(float(werte[0]), float(werte[1]), float(werte[2]))
## Liest die Streckentabelle; leere Tabelle bei Fehlern.
func _lade() -> Dictionary:
if not FileAccess.file_exists(DATEI):
push_error("Flugstrecken nicht lesbar: %s" % DATEI)
return {}
var geparst: Variant = JSON.parse_string(FileAccess.get_file_as_string(DATEI))
if not (geparst is Dictionary):
push_error("Flugstrecken sind ungültig: %s" % DATEI)
return {}
return geparst.get("strecken", {})