diff --git a/data/story/flugstrecken.json b/data/story/flugstrecken.json new file mode 100644 index 0000000..c09a20b --- /dev/null +++ b/data/story/flugstrecken.json @@ -0,0 +1,67 @@ +{ + "_entwurf": "CR 51 — die vier inszenierten Flugstrecken. Struktur und Beats stammen aus Mikes Raumkonzept (2026-09-12) und den _regie-Bloecken der Dialogdateien. ⚠️ DIE KOORDINATEN SIND PLATZHALTER: Die Orte baut Mike gerade. Ersetzt werden muessen nur die pos-Werte je Wegpunkt — Reihenfolge, Ereignisse und Tempo stimmen bereits. Getestet wird bis dahin mit Platzhalter-Geometrie. — tempo = Metern pro Sekunde entlang der Strecke (zeitgeraffte Strecken laufen schneller). korridor = wie weit der Spieler seitlich/hoch von der Route abweichen darf; die Strecke selbst bleibt fest. ereignis an einem Wegpunkt wird als Signal gemeldet, damit die Szene dort ihren Beat einhaengen kann.", + "strecken": { + "akt2_lieferung": { + "titel": "Lieferflug — Basgiath zum Abwurfpunkt", + "szenen": ["akt2_k2_lieferung_erste"], + "tempo": 16.0, + "korridor": { "seite": 7.0, "hoehe": 5.0 }, + "wegpunkte": [ + { "id": "basgiath", "pos": [0, 60, 0] }, + { "id": "ueber_land", "pos": [0, 70, -120] }, + { "id": "anflug_dorf", "pos": [40, 45, -240], "ereignis": "dorf_in_sicht" }, + { "id": "abwurfpunkt", "pos": [60, 12, -300], "ereignis": "ankunft" } + ] + }, + "akt2_montserrat": { + "titel": "Montserrat — sechs Stunden hin, sechs zurueck", + "szenen": ["akt2_k4_montserrat_ankunft", "akt2_k4_montserrat_angriff"], + "tempo": 34.0, + "zeitgerafft": true, + "korridor": { "seite": 9.0, "hoehe": 6.0 }, + "wegpunkte": [ + { "id": "basgiath", "pos": [0, 80, 0] }, + { "id": "hochland", "pos": [-140, 110, -220] }, + { "id": "felssporn_sicht", "pos": [-260, 90, -430], "ereignis": "montserrat_in_sicht" }, + { "id": "ankunftsplatz", "pos": [-300, 30, -500], "ereignis": "ankunft" } + ], + "rueckweg": { + "tempo": 34.0, + "wegpunkte": [ + { "id": "abflug", "pos": [-300, 40, -500] }, + { "id": "offenes_land", "pos": [-160, 100, -260] }, + { "id": "greifen", "pos": [-60, 95, -90], "ereignis": "greifen_angriff" }, + { "id": "basgiath", "pos": [0, 70, 0], "ereignis": "ankunft" } + ] + } + }, + "akt3_aretia": { + "titel": "Aretia — ueber die Cliffs of Dralor", + "szenen": ["akt3_k5_abschied", "akt3_k5_aretia"], + "tempo": 38.0, + "zeitgerafft": true, + "korridor": { "seite": 9.0, "hoehe": 6.0 }, + "wegpunkte": [ + { "id": "aufbruch", "pos": [0, 70, 0] }, + { "id": "cliffs_of_dralor", "pos": [180, 120, -260], "ereignis": "cliffs" }, + { "id": "tal", "pos": [300, 80, -460] }, + { "id": "ueber_der_stadt", "pos": [360, 45, -560], "ereignis": "kerzen_sichtbar" }, + { "id": "ankunft", "pos": [380, 14, -600], "ereignis": "ankunft" } + ] + }, + "akt3_resson_anflug": { + "titel": "Resson — Formationsflug zur Ostseite", + "szenen": ["akt3_k1_anflug", "akt3_k1_erste_sichtung", "akt3_k1_ostseite"], + "tempo": 26.0, + "formation": true, + "korridor": { "seite": 5.0, "hoehe": 4.0 }, + "wegpunkte": [ + { "id": "sammelpunkt", "pos": [0, 90, 0] }, + { "id": "grenzland", "pos": [-90, 85, -200] }, + { "id": "erste_sichtung", "pos": [-150, 60, -340], "ereignis": "erste_sichtung" }, + { "id": "feld", "pos": [-190, 30, -430] }, + { "id": "ostseite", "pos": [-210, 8, -480], "ereignis": "encounter" } + ] + } + } +} diff --git a/scenes/akt2/flugtest.tscn b/scenes/akt2/flugtest.tscn new file mode 100644 index 0000000..07bad56 --- /dev/null +++ b/scenes/akt2/flugtest.tscn @@ -0,0 +1,43 @@ +[gd_scene load_steps=7 format=3] + +[ext_resource type="Script" path="res://scripts/gameplay/flugstrecke.gd" id="1_flug"] + +[sub_resource type="ProceduralSkyMaterial" id="Sky_mat"] +sky_horizon_color = Color(0.62, 0.65, 0.7, 1) +ground_horizon_color = Color(0.62, 0.65, 0.7, 1) + +[sub_resource type="Sky" id="Sky"] +sky_material = SubResource("Sky_mat") + +[sub_resource type="Environment" id="Env"] +background_mode = 2 +sky = SubResource("Sky") +tonemap_mode = 2 + +[sub_resource type="StandardMaterial3D" id="Mat_rig"] +albedo_color = Color(0.1, 0.09, 0.11, 1) + +[sub_resource type="BoxMesh" id="Mesh_rig"] +material = SubResource("Mat_rig") +size = Vector3(4, 1.4, 7) + +[node name="Flugtest" type="Node3D"] +script = ExtResource("1_flug") +strecken_id = "akt2_lieferung" + +[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="Rig" type="Node3D" parent="."] + +[node name="MeshInstance3D" type="MeshInstance3D" parent="Rig"] +mesh = SubResource("Mesh_rig") + +[node name="Kamera" type="Camera3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 64, 12) +current = true +far = 4000.0 diff --git a/scripts/gameplay/flugstrecke.gd b/scripts/gameplay/flugstrecke.gd new file mode 100644 index 0000000..72a8bc5 --- /dev/null +++ b/scripts/gameplay/flugstrecke.gd @@ -0,0 +1,247 @@ +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", {}) diff --git a/scripts/gameplay/flugstrecke.gd.uid b/scripts/gameplay/flugstrecke.gd.uid new file mode 100644 index 0000000..4219331 --- /dev/null +++ b/scripts/gameplay/flugstrecke.gd.uid @@ -0,0 +1 @@ +uid://blufxa3hn61rp