153 lines
5 KiB
GDScript
153 lines
5 KiB
GDScript
extends Node3D
|
|
## Rival-Kadetten des Ernstlaufs (CR-002 §7, Serpentine per CR-003) —
|
|
## rein ambient.
|
|
##
|
|
## Nur im exam-Modus: rival_count Kadetten-Silhouetten laufen die
|
|
## Terrassen-Serpentine auf quer versetzten Linien (rival_line_offsets,
|
|
## seitlich zur Laufrichtung) ab, ohne Kollision mit Tyrveil. Sichtbare
|
|
## Tode: Der Zeitplan rival_fall_schedule lässt Kadetten nacheinander
|
|
## abstürzen (Fall-Tween in den Nebel + Verschwinden); als Kanon-Anker
|
|
## stirbt der erste Kadett, der das Höhenband der Rolling Logs erreicht,
|
|
## dort IMMER (Quetschung). Im manipulated-Preset läuft der Zeitplan
|
|
## gerafft. Jeder Sturz speist über rival_fell das Nerven-System —
|
|
## Sichtlinie darauf bieten besonders die Kurven.
|
|
|
|
signal rival_fell(rival_id: int, terrace_index: int)
|
|
|
|
@export var rival_count := 5
|
|
@export var rival_climb_speed := 1.6
|
|
@export var rival_fall_schedule: PackedFloat32Array = PackedFloat32Array([18.0, 42.0])
|
|
@export var rival_line_offsets: PackedFloat32Array = PackedFloat32Array([-0.7, -0.35, 0.35, 0.7, -1.0])
|
|
|
|
var _spine: Array[Vector3] = []
|
|
var _terrace_breaks: PackedFloat32Array = PackedFloat32Array()
|
|
var _crush_band := Vector2.ZERO
|
|
var _rivals: Array[Node3D] = []
|
|
var _distances: Array[float] = []
|
|
var _is_active := false
|
|
var _elapsed := 0.0
|
|
var _next_fall := 0
|
|
var _has_crush_death := false
|
|
var _spine_length := 0.0
|
|
|
|
|
|
## Verknüpft Serpentinen-Linie, Terrassen-Grenzen (Höhen) und das
|
|
## Quetsch-Höhenband der Rolling Logs und spawnt die Kadetten.
|
|
func setup(spine: Array[Vector3], terrace_breaks: PackedFloat32Array, crush_band: Vector2, haste_scale: float) -> void:
|
|
_spine = spine
|
|
_terrace_breaks = terrace_breaks
|
|
_crush_band = crush_band
|
|
for i in _spine.size() - 1:
|
|
_spine_length += _spine[i].distance_to(_spine[i + 1])
|
|
for i in rival_count:
|
|
var rival := _make_rival(i)
|
|
add_child(rival)
|
|
_rivals.append(rival)
|
|
_distances.append(-3.0 * float(i))
|
|
if haste_scale != 1.0:
|
|
for i in rival_fall_schedule.size():
|
|
rival_fall_schedule[i] *= haste_scale
|
|
|
|
|
|
## Startet die Kletterei (Beginn des Ernstlaufs).
|
|
func start() -> void:
|
|
_is_active = true
|
|
_elapsed = 0.0
|
|
|
|
|
|
## Stoppt die Kletterei (nach dem Wendepunkt: Training ohne Rivalen).
|
|
func stop() -> void:
|
|
_is_active = false
|
|
for rival in _rivals:
|
|
rival.visible = false
|
|
|
|
|
|
## Anzahl noch laufender Kadetten (für Tests/Overlay).
|
|
func alive_count() -> int:
|
|
var count := 0
|
|
for rival in _rivals:
|
|
if rival.visible:
|
|
count += 1
|
|
return count
|
|
|
|
|
|
## Bewegt die Kadetten die Serpentine entlang und arbeitet den
|
|
## Sturz-Zeitplan sowie den Kanon-Tod an den Rolling Logs ab.
|
|
func _physics_process(delta: float) -> void:
|
|
if not _is_active or DialogueSystem.is_dialogue_active:
|
|
return
|
|
_elapsed += delta
|
|
for i in _rivals.size():
|
|
var rival := _rivals[i]
|
|
if not rival.visible:
|
|
continue
|
|
_distances[i] += rival_climb_speed * delta
|
|
var travelled: float = clampf(_distances[i], 0.0, _spine_length)
|
|
var point := _sample_spine(travelled)
|
|
point.z += rival_line_offsets[i % rival_line_offsets.size()]
|
|
rival.global_position = point
|
|
if not _has_crush_death and point.y >= _crush_band.x and point.y <= _crush_band.y:
|
|
_has_crush_death = true
|
|
_kill_rival(i)
|
|
continue
|
|
if _distances[i] >= _spine_length:
|
|
rival.visible = false
|
|
if _next_fall < rival_fall_schedule.size() and _elapsed >= rival_fall_schedule[_next_fall]:
|
|
_kill_scheduled()
|
|
|
|
|
|
## Lässt den nächsten planmäßigen Kadetten stürzen (sofern noch einer
|
|
## läuft).
|
|
func _kill_scheduled() -> void:
|
|
_next_fall += 1
|
|
for i in _rivals.size():
|
|
if _rivals[i].visible:
|
|
_kill_rival(i)
|
|
return
|
|
|
|
|
|
## Spielt den Sturz eines Kadetten: Fall-Tween in den Nebel, verschwinden,
|
|
## Signal an das Nerven-System.
|
|
func _kill_rival(index: int) -> void:
|
|
var rival := _rivals[index]
|
|
var terrace := _terrace_at(rival.global_position.y)
|
|
var tween := create_tween()
|
|
tween.tween_property(rival, "global_position:y", rival.global_position.y - 30.0, 1.2)
|
|
tween.tween_callback(func() -> void: rival.visible = false)
|
|
rival_fell.emit(index, terrace)
|
|
|
|
|
|
## Ordnet eine Höhe dem Terrassen-Index 1..5 zu.
|
|
func _terrace_at(y: float) -> int:
|
|
for i in _terrace_breaks.size():
|
|
if y < _terrace_breaks[i]:
|
|
return i + 1
|
|
return _terrace_breaks.size() + 1
|
|
|
|
|
|
## Interpoliert einen Punkt in gegebener Distanz entlang der Serpentine.
|
|
func _sample_spine(travelled: float) -> Vector3:
|
|
var remaining := travelled
|
|
for i in _spine.size() - 1:
|
|
var segment := _spine[i].distance_to(_spine[i + 1])
|
|
if remaining <= segment:
|
|
return _spine[i].lerp(_spine[i + 1], remaining / maxf(segment, 0.01))
|
|
remaining -= segment
|
|
return _spine[_spine.size() - 1]
|
|
|
|
|
|
## Baut die Kadetten-Silhouette (dunkle Kapsel, keine Kollision).
|
|
func _make_rival(index: int) -> Node3D:
|
|
var rival := Node3D.new()
|
|
rival.name = "Rival%d" % (index + 1)
|
|
var mesh_instance := MeshInstance3D.new()
|
|
var capsule := CapsuleMesh.new()
|
|
capsule.radius = 0.35
|
|
capsule.height = 1.7
|
|
var material := StandardMaterial3D.new()
|
|
material.albedo_color = Color(0.28, 0.28, 0.34)
|
|
capsule.material = material
|
|
mesh_instance.mesh = capsule
|
|
mesh_instance.position.y = 0.85
|
|
rival.add_child(mesh_instance)
|
|
return rival
|