CR 51: Wegpunkt-Flugsystem fuer die vier inszenierten Fluege

Grundmechanik, die alle vier geplanten Flugsequenzen teilen: fester Pfad,
Kamera folgt, Spieler behaelt Steuerung — aber nur innerhalb der Strecke.
Kette von Wegpunkten statt Einzel-Schwenk, Vorbild play_camera_pan.

Vorwaerts kommt man nicht durchs Steuern, sondern weil die Strecke laeuft;
steuern kann man quer dazu, hart begrenzt durch den korridor der Strecke.
Wer nichts drueckt, fliegt die Route trotzdem sauber ab. Damit ist es
ausdruecklich kein freies Fliegen — das bleibt AKT2.md §7 (10).

Beats haengen an Wegpunkten: Traegt ein Wegpunkt ein ereignis, meldet die
Strecke es beim Passieren. So haengt eine Szene ihren Greifen-Angriff oder
das Encounter an, ohne dass die Klasse die Story kennt. Strecken mit
Rueckweg (Montserrat) laufen ueber einen benannten Zweig.

Die vier Strecken stehen in data/story/flugstrecken.json, Reihenfolge,
Ereignisse und Tempo aus Mikes Raumkonzept. Die Koordinaten sind noch
PLATZHALTER und als solche markiert — die Mechanik haengt nicht daran,
ersetzt werden spaeter nur die pos-Werte. Getestet wird bis dahin ueber
scenes/akt2/flugtest.tscn mit Platzhalter-Geometrie.

Ein echter Fehler beim Verifizieren gefunden und behoben: Die
Wegpunkt-Distanzen lagen als float32 vor, verglichen wurde gegen die
float64-Kurvenlaenge. Rundete die letzte Distanz minimal nach oben, wurde
sie nie erreicht — und damit fiel das ANKUNFTS-Ereignis lautlos aus, genau
das, an dem die Szenen haengen werden (ankunft, encounter). Beim Rueckweg
fiel die Rundung zufaellig andersherum aus, dort war es unsichtbar. Die
Distanzen werden jetzt auf die gebackene Kurvenlaenge normiert.

Verifikation, Sonde 18/18 mit Kontrollen:
- Kontrolle: ohne Eingabe bleibt der Reiter exakt auf der Route (Versatz
  0.000) und wird trotzdem vorwaerts getragen.
- Kontrolle: mit Dauer-Eingabe weicht er aus, aber nur bis zur
  Korridor-Grenze (7.00 von 7.00) — kein freies Fliegen.
- Wegpunkte feuern in Reihenfolge samt Ereignis, Start und Ende sitzen auf
  dem ersten bzw. letzten Wegpunkt, die Strecke beendet sich selbst.
- Montserrat-Rueckweg: Greifen-Zwischenfall kommt nachweislich VOR der
  Ankunft. Unbekannte Strecke wird sauber abgelehnt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-12 14:05:58 +02:00
parent d525a10408
commit 2087c8c3ab
4 changed files with 358 additions and 0 deletions

View file

@ -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" }
]
}
}
}

43
scenes/akt2/flugtest.tscn Normal file
View file

@ -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

View file

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

View file

@ -0,0 +1 @@
uid://blufxa3hn61rp