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>
250 lines
8.6 KiB
GDScript
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", {})
|