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:
parent
d525a10408
commit
2087c8c3ab
4 changed files with 358 additions and 0 deletions
247
scripts/gameplay/flugstrecke.gd
Normal file
247
scripts/gameplay/flugstrecke.gd
Normal 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", {})
|
||||
1
scripts/gameplay/flugstrecke.gd.uid
Normal file
1
scripts/gameplay/flugstrecke.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://blufxa3hn61rp
|
||||
Loading…
Add table
Add a link
Reference in a new issue