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) 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", {})