CR-002/CR-003: Gauntlet als vertikaler Kletter-Parcours mit 5 Ascents, ohne Wind
- Gauntlet komplett neu: fuenf Ascent-Sub-Scenes an der Felswand (Fuss bis Box-Canyon ~38 m), verbunden ueber schulterbreite Kies-Pfade (Training: Checkpoint/Rast, Ernstlauf: Durchgang); Nebel, KillZone, Treppen-Visual, 4 Drachen-Silhouetten am Box-Canyon-Eingang - 10 wiederverwendbare Hindernis-Scenes: spinning_log, granite_pillar, spinning_wheel (Ausstiegs-Timing), buoy_ball (momentum_swing: laden + im Scheitel loslassen), iron_rail (A/D- bzw. LB/RB-Wechsel-Hangeln), shaking_pillar, rolling_log (Tempo-Pflicht, Quetsch-Tod, No-Rope), leaning_chimney (X-Spreiz-Modus, kein Seil-Behelf), vertical_ramp (Sprint-Momentum), cliff_ledge (bestehendes Kanten-Klettersystem) - Sicherungsseile alle ~6 Fuss: Sturz oeffnet Greif-Fenster (Leertaste/A), Fang = letzter Absatz + 30 s Strafe, sonst Death-State; No-Rope-Zone an den Rolling Logs; Ernstlauf sperrt Absteigen - run_timer (Zeitlauf nur im exam), rival_climbers (5 Kadetten, Sturz-Zeitplan + Kanon-Tod an den Rolling Logs), nerve_system (Rival-Tode/Ablenkung/Blick nach unten verschlechtern Griff; Steady = Strg/L2 senkt Nerven, blockt Klettern), climb_controller (Griff-HUD), gauntlet_mode (training/exam + manipulated-Preset) - CR-003: Wind aus dem Gauntlet entfernt - Drachen-Ablenkung ohne Seitenruck und ohne Gegensteuer-QTE (reines Nerven-Ereignis), balance_qte auf CR-001-Stand zurueck (Wind nur am Viadukt) - Story Phase 4c unangetastet auf neuer Geometrie: Auftakt, Intervention am Sammel-Absatz vor Ascent 5, Marens Tod, Wahrheiten, Trauer-Wahl; erster Besuch = manipulierter Ernstlauf, danach freies Training; story_hook_reached(ascent_index) als Anker fuer den Story-CR - neue Input-Actions steady/swing_charge/grab_rope/hangel_left/ hangel_right/look_down; Tuning daten-getrieben unter data/gauntlet/ (gauntlet_tuning.tres + ascent_1..5.tres) - Verifikation: Headless-Sonde 91/97 gruen (Rest: Buoy-Folgefehler, Fix umgesetzt, Bestaetigungslauf auf Wunsch uebersprungen); Boot-Check aller 6 Szenen fehlerfrei Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
parent
1d8d3bc342
commit
6f92fc0ae0
66 changed files with 2661 additions and 304 deletions
104
scripts/gameplay/obstacles/buoy_ball.gd
Normal file
104
scripts/gameplay/obstacles/buoy_ball.gd
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
extends GauntletObstacle
|
||||
## Buoy Ball (CR-002, ascent_2): hängende Kugel zum Umklammern und
|
||||
## Anschwingen (momentum_swing, CR §8b).
|
||||
##
|
||||
## Die Kugel pendelt entlang der Laufrichtung. Springt der Spieler in die
|
||||
## Greif-Zone, klammert er sich fest und pendelt mit. Schwung-Taste
|
||||
## (Leertaste/A) halten lädt über momentum_charge_time den Schwung;
|
||||
## Loslassen im Scheitel-Fenster (launch_window) katapultiert zur
|
||||
## launch_target-Position (nächste Kugel oder Absatz). Zu früh/zu spät/
|
||||
## ungeladen gelöst -> zu kurz -> Sturz (player_fell).
|
||||
|
||||
@export var buoy_swing_period := 2.4
|
||||
@export var swing_amplitude := 1.2
|
||||
@export var launch_window := 0.5
|
||||
@export var momentum_charge_time := 0.9
|
||||
@export var launch_target := Vector3(0, 1.2, -2.6)
|
||||
|
||||
var _ball: MeshInstance3D
|
||||
var _grab_area: Area3D
|
||||
var _time := 0.0
|
||||
var _is_holding := false
|
||||
var _charge := 0.0
|
||||
var _was_charging := false
|
||||
|
||||
|
||||
## Baut Kugel, Seil-Visual und Greif-Zone.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
_ball = MeshInstance3D.new()
|
||||
var sphere := SphereMesh.new()
|
||||
sphere.radius = 0.5
|
||||
sphere.height = 1.0
|
||||
sphere.material = _make_material(Color(0.75, 0.3, 0.25))
|
||||
_ball.mesh = sphere
|
||||
add_child(_ball)
|
||||
add_child(build_box_mesh(Vector3(0.06, 2.4, 0.06), Vector3(0, 1.5, 0), Color(0.3, 0.28, 0.25)))
|
||||
_grab_area = build_area(self, Vector3(2.2, 2.8, 2.2 + swing_amplitude * 2.0), Vector3(0, -0.9, 0))
|
||||
_grab_area.body_entered.connect(_on_grab)
|
||||
|
||||
|
||||
## Pendelt die Kugel; hält der Spieler sich fest, folgt er ihr, lädt
|
||||
## Schwung und wird beim Loslassen ausgewertet.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_time += delta
|
||||
var phase := _time * TAU / buoy_swing_period
|
||||
_ball.position = Vector3(0, 0, sin(phase) * swing_amplitude)
|
||||
_grab_area.position = _ball.position + Vector3(0, -0.9, 0)
|
||||
if not _is_holding:
|
||||
return
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
player.velocity = Vector3.ZERO
|
||||
player.global_position = to_global(_ball.position + Vector3(0, -1.5, 0))
|
||||
var is_charging := Input.is_action_pressed("swing_charge")
|
||||
if is_charging:
|
||||
_charge = minf(_charge + delta / momentum_charge_time, 1.0)
|
||||
show_prompt("Schwung laden: %d%% — im Scheitel loslassen (Leertaste / A-Taste)" % int(_charge * 100.0))
|
||||
elif _was_charging:
|
||||
_release(player)
|
||||
else:
|
||||
show_prompt("Leertaste / A-Taste HALTEN — Schwung laden")
|
||||
_was_charging = is_charging
|
||||
|
||||
|
||||
## Klammert den Spieler an die Kugel, wenn er frei in die Greif-Zone kommt.
|
||||
func _on_grab(body: Node3D) -> void:
|
||||
if _is_holding or not body.is_in_group("player"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
_is_holding = true
|
||||
_charge = 0.0
|
||||
_was_charging = false
|
||||
player.set_control_locked(true)
|
||||
|
||||
|
||||
## Wertet das Loslassen aus: voll geladen im Scheitel-Fenster -> Launch zum
|
||||
## Ziel, sonst zu kurz -> Sturz.
|
||||
func _release(player: CharacterBody3D) -> void:
|
||||
_is_holding = false
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
if _charge >= 1.0 and _is_in_launch_window():
|
||||
player.global_position = to_global(launch_target)
|
||||
player.velocity = Vector3.ZERO
|
||||
mark_cleared()
|
||||
else:
|
||||
player.velocity = Vector3(0, -8.0, 0)
|
||||
report_fall()
|
||||
|
||||
|
||||
## Prüft, ob das Pendel gerade im Scheitel-Fenster steht (Geschwindigkeit
|
||||
## nahe null an den Umkehrpunkten).
|
||||
func _is_in_launch_window() -> bool:
|
||||
var phase := fposmod(_time * TAU / buoy_swing_period, PI)
|
||||
var window_half := TAU * launch_window / buoy_swing_period / 2.0
|
||||
return absf(phase - PI / 2.0) < maxf(window_half, 0.15)
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade an der Kugel hängt (für Tests).
|
||||
func is_holding() -> bool:
|
||||
return _is_holding
|
||||
1
scripts/gameplay/obstacles/buoy_ball.gd.uid
Normal file
1
scripts/gameplay/obstacles/buoy_ball.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://ouipe8d7atdg
|
||||
25
scripts/gameplay/obstacles/cliff_ledge.gd
Normal file
25
scripts/gameplay/obstacles/cliff_ledge.gd
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
extends GauntletObstacle
|
||||
## Cliff Ledge (CR-002, ascent_5): finaler Griffabsatz.
|
||||
##
|
||||
## Eine Felskante in Griffhöhe (ledge_reach) — der Sprung dagegen löst das
|
||||
## bestehende Kanten-Klettersystem aus (Phase 1b), Tyrveil zieht sich hoch
|
||||
## und der Kurs ist geschafft. Der Clear-Trigger oben meldet das Ende.
|
||||
|
||||
@export var ledge_reach := 2.0
|
||||
@export var wall_width := 4.0
|
||||
|
||||
var _clear_trigger: Area3D
|
||||
|
||||
|
||||
## Baut die Kantenwand und den Clear-Trigger auf der Oberseite.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
build_box(self, Vector3(wall_width, ledge_reach, 1.0), Vector3(0, ledge_reach / 2.0, 0), Color(0.5, 0.48, 0.46))
|
||||
_clear_trigger = build_area(self, Vector3(wall_width + 2.0, 2.4, 3.2), Vector3(0, ledge_reach + 1.0, -1.0))
|
||||
_clear_trigger.body_entered.connect(_on_top_reached)
|
||||
|
||||
|
||||
## Oben angekommen: Hindernis (und damit der Kurs) geschafft.
|
||||
func _on_top_reached(body: Node3D) -> void:
|
||||
if body.is_in_group("player"):
|
||||
mark_cleared()
|
||||
1
scripts/gameplay/obstacles/cliff_ledge.gd.uid
Normal file
1
scripts/gameplay/obstacles/cliff_ledge.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://bbgq3utewlli8
|
||||
15
scripts/gameplay/obstacles/granite_pillar.gd
Normal file
15
scripts/gameplay/obstacles/granite_pillar.gd
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
extends GauntletObstacle
|
||||
## Granit-Sprungpfeiler (CR-002, ascent_1) — statischer Greybox-Block.
|
||||
##
|
||||
## Dient zugleich als generische Plattform (Lande-Absätze, Ausstiege),
|
||||
## da er nur aus einer konfigurierbaren Box besteht. Der Aufstieg über
|
||||
## mehrere Pfeiler nutzt das bestehende Kanten-Klettersystem (jump).
|
||||
|
||||
@export var size := Vector3(0.9, 1.7, 0.9)
|
||||
@export var color := Color(0.55, 0.54, 0.52)
|
||||
|
||||
|
||||
## Baut den Pfeiler; die Oberkante liegt bei position.y + size.y.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
build_box(self, size, Vector3(0, size.y / 2.0, 0), color)
|
||||
1
scripts/gameplay/obstacles/granite_pillar.gd.uid
Normal file
1
scripts/gameplay/obstacles/granite_pillar.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://cq38s83h3f5bo
|
||||
109
scripts/gameplay/obstacles/iron_rail.gd
Normal file
109
scripts/gameplay/obstacles/iron_rail.gd
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
extends GauntletObstacle
|
||||
## Iron Rails (CR-002, ascent_3): waagerechte Schienen zum Hangeln.
|
||||
##
|
||||
## Baut rail_count Schienen Ende-an-Ende, jede um rail_height_step höher
|
||||
## (Höhenversatz erzwingt Nachgreifen). Der Spieler springt an den Anfang,
|
||||
## hängt darunter und hangelt Hand über Hand: A und D (bzw. LB/RB) im
|
||||
## Wechsel, jeder korrekte Tap innerhalb hangel_rhythm_window schiebt ein
|
||||
## Stück weiter. Falsche Hand oder Rhythmus gerissen -> Sturz
|
||||
## (player_fell). Am Ende lässt Tyrveil sich auf den Lande-Absatz fallen.
|
||||
|
||||
@export var rail_count := 3
|
||||
@export var rail_length := 4.0
|
||||
@export var rail_height_step := 0.15
|
||||
@export var rail_base_height := 2.6
|
||||
@export var hangel_rhythm_window := 1.1
|
||||
@export var hangel_step := 0.45
|
||||
@export var drop_target := Vector3(0, 1.4, -12.8)
|
||||
|
||||
var _is_hanging := false
|
||||
var _progress := 0.0
|
||||
var _expected_dir := -1
|
||||
var _rhythm_timer := 0.0
|
||||
var _total_length := 0.0
|
||||
|
||||
|
||||
## Baut die Schienen und die Greif-Zone am Anfang.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
_total_length = rail_length * float(rail_count)
|
||||
for i in rail_count:
|
||||
var y := rail_base_height + rail_height_step * float(i)
|
||||
add_child(build_box_mesh(Vector3(0.12, 0.12, rail_length), Vector3(0, y, -rail_length / 2.0 - rail_length * float(i)), Color(0.35, 0.35, 0.4)))
|
||||
var grab := build_area(self, Vector3(1.6, 1.8, 1.2), Vector3(0, rail_base_height - 1.0, -0.4))
|
||||
grab.body_entered.connect(_on_grab)
|
||||
|
||||
|
||||
## Führt den hängenden Spieler und wertet den Hangel-Rhythmus aus.
|
||||
func _physics_process(delta: float) -> void:
|
||||
if not _is_hanging:
|
||||
return
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
var rail_index := clampi(int(_progress / rail_length), 0, rail_count - 1)
|
||||
var y := rail_base_height + rail_height_step * float(rail_index)
|
||||
player.velocity = Vector3.ZERO
|
||||
player.global_position = to_global(Vector3(0, y - 1.75, -_progress))
|
||||
_rhythm_timer += delta
|
||||
var window := hangel_rhythm_window
|
||||
if mode != null:
|
||||
window *= mode.window_scale()
|
||||
if _rhythm_timer > window:
|
||||
_fail(player)
|
||||
return
|
||||
var next_hand := "A / LB" if _expected_dir < 0 else "D / RB"
|
||||
show_prompt("Hangeln: %s — Hand über Hand im Wechsel" % next_hand)
|
||||
var pressed_dir := 0
|
||||
if Input.is_action_just_pressed("hangel_left"):
|
||||
pressed_dir = -1
|
||||
elif Input.is_action_just_pressed("hangel_right"):
|
||||
pressed_dir = 1
|
||||
if pressed_dir == 0:
|
||||
return
|
||||
if pressed_dir != _expected_dir:
|
||||
_fail(player)
|
||||
return
|
||||
_expected_dir = -_expected_dir
|
||||
_rhythm_timer = 0.0
|
||||
_progress += hangel_step
|
||||
if _progress >= _total_length:
|
||||
_finish(player)
|
||||
|
||||
|
||||
## Hängt den Spieler an die erste Schiene, wenn er frei zugreift.
|
||||
func _on_grab(body: Node3D) -> void:
|
||||
if _is_hanging or not body.is_in_group("player"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
_is_hanging = true
|
||||
_progress = 0.3
|
||||
_expected_dir = -1
|
||||
_rhythm_timer = 0.0
|
||||
player.set_control_locked(true)
|
||||
|
||||
|
||||
## Ende erreicht: auf den Lande-Absatz fallen lassen.
|
||||
func _finish(player: CharacterBody3D) -> void:
|
||||
_is_hanging = false
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
player.global_position = to_global(drop_target)
|
||||
player.velocity = Vector3.ZERO
|
||||
mark_cleared()
|
||||
|
||||
|
||||
## Rhythmus gerissen oder falsche Hand: Sturz.
|
||||
func _fail(player: CharacterBody3D) -> void:
|
||||
_is_hanging = false
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
player.velocity = Vector3.ZERO
|
||||
report_fall()
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade hangelt (für Tests).
|
||||
func is_hanging() -> bool:
|
||||
return _is_hanging
|
||||
1
scripts/gameplay/obstacles/iron_rail.gd.uid
Normal file
1
scripts/gameplay/obstacles/iron_rail.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://4tnoonm8372n
|
||||
106
scripts/gameplay/obstacles/leaning_chimney.gd
Normal file
106
scripts/gameplay/obstacles/leaning_chimney.gd
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
extends GauntletObstacle
|
||||
## Leaning Chimney (CR-002, ascent_5): schräger Kaminschacht, X-Spreiz.
|
||||
##
|
||||
## Tyrveil spreizt sich direkt zwischen die beiden Wände (Standard-Technik,
|
||||
## KEIN Seil-Behelf — der Behelf der Buch-Protagonistin für kleinere
|
||||
## Kletterer wird bewusst nicht gebaut, nur hier vermerkt). Mini-Modus:
|
||||
## W/Stick hoch schiebt eine Spreiz-Stufe hoch, A/D hält den Spreizdruck
|
||||
## balanciert, während der Druck zufällig wegdriftet (Nerven-System
|
||||
## verstärkt die Drift). Kippt die Balance über chimney_brace_tolerance,
|
||||
## rutscht Tyrveil ab (player_fell).
|
||||
|
||||
@export var chimney_height := 6.0
|
||||
@export var step_height := 1.0
|
||||
@export var chimney_brace_tolerance := 0.5
|
||||
@export var chimney_drift_speed := 0.45
|
||||
@export var exit_target := Vector3(0, 6.3, -2.5)
|
||||
|
||||
var _is_bracing := false
|
||||
var _height := 0.0
|
||||
var _balance := 0.0
|
||||
var _drift_dir := 1.0
|
||||
|
||||
|
||||
## Baut die beiden geneigten Kaminwände und die Einstiegs-Zone am Fuß.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
var lean := deg_to_rad(10.0)
|
||||
for side in [-1.0, 1.0]:
|
||||
var wall := build_box(self, Vector3(0.5, chimney_height + 2.0, 2.4), Vector3(side * 1.05, chimney_height / 2.0, -1.0), Color(0.5, 0.48, 0.46))
|
||||
wall.rotation.z = lean * side * 0.35
|
||||
var entry := build_area(self, Vector3(1.4, 1.6, 1.8), Vector3(0, 0.8, -1.0))
|
||||
entry.body_entered.connect(_on_entry)
|
||||
|
||||
|
||||
## Treibt den Spreiz-Modus: Drift auf die Balance, A/D hält dagegen,
|
||||
## W schiebt stufenweise hoch.
|
||||
func _physics_process(delta: float) -> void:
|
||||
if not _is_bracing:
|
||||
return
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
player.velocity = Vector3.ZERO
|
||||
player.global_position = to_global(Vector3(_balance * 0.4, _height + 0.9, -1.0))
|
||||
var drift := chimney_drift_speed
|
||||
if nerve != null:
|
||||
drift *= nerve.drift_factor()
|
||||
_balance += drift * _drift_dir * delta
|
||||
var axis := Input.get_axis("move_left", "move_right")
|
||||
_balance += axis * 1.6 * delta
|
||||
if absf(_balance) > chimney_brace_tolerance:
|
||||
_slip(player)
|
||||
return
|
||||
show_prompt("X-SPREIZ — W/Stick hoch: Stufe · A/D: Druck halten [%s]" % _balance_bar())
|
||||
if Input.is_action_just_pressed("move_forward"):
|
||||
_height += step_height
|
||||
_drift_dir = 1.0 if randf() < 0.5 else -1.0
|
||||
if _height >= chimney_height:
|
||||
_finish(player)
|
||||
|
||||
|
||||
## Startet den Spreiz-Modus am Kaminfuß.
|
||||
func _on_entry(body: Node3D) -> void:
|
||||
if _is_bracing or not body.is_in_group("player"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
_is_bracing = true
|
||||
_height = 0.4
|
||||
_balance = 0.0
|
||||
_drift_dir = 1.0 if randf() < 0.5 else -1.0
|
||||
player.set_control_locked(true)
|
||||
|
||||
|
||||
## Oben angekommen: auf den Ausstiegs-Absatz steigen.
|
||||
func _finish(player: CharacterBody3D) -> void:
|
||||
_is_bracing = false
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
player.global_position = to_global(exit_target)
|
||||
player.velocity = Vector3.ZERO
|
||||
mark_cleared()
|
||||
|
||||
|
||||
## Spreizdruck gekippt: Abrutschen.
|
||||
func _slip(player: CharacterBody3D) -> void:
|
||||
_is_bracing = false
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
player.velocity = Vector3.ZERO
|
||||
report_fall()
|
||||
|
||||
|
||||
## Baut eine kleine Text-Anzeige der Balance-Lage für den Prompt.
|
||||
func _balance_bar() -> String:
|
||||
var slot := clampi(int(roundf(_balance / chimney_brace_tolerance * 3.0)), -3, 3)
|
||||
var bar := ""
|
||||
for i in range(-3, 4):
|
||||
bar += "o" if i == slot else "-"
|
||||
return bar
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade im Kamin spreizt (für Tests).
|
||||
func is_bracing() -> bool:
|
||||
return _is_bracing
|
||||
1
scripts/gameplay/obstacles/leaning_chimney.gd.uid
Normal file
1
scripts/gameplay/obstacles/leaning_chimney.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://rgb8it7gggna
|
||||
153
scripts/gameplay/obstacles/obstacle_base.gd
Normal file
153
scripts/gameplay/obstacles/obstacle_base.gd
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
class_name GauntletObstacle
|
||||
extends Node3D
|
||||
## Basisklasse aller Gauntlet-Hindernisse (CR-002).
|
||||
##
|
||||
## Liefert die gemeinsame Infrastruktur: Signale cleared/player_fell,
|
||||
## Greybox-Baukasten für Boxen, Zylinder und Trigger-Areas, Zugriff auf
|
||||
## den Spieler sowie einen Bildschirm-Prompt (Tastatur- UND
|
||||
## Controller-Glyphe als Text, solange InputPrompts noch Skelett ist).
|
||||
## Hindernisse registrieren sich in der Gruppe gauntlet_obstacle; die
|
||||
## Szenen-Steuerung injiziert über setup_context Nerven-System und Modus.
|
||||
|
||||
signal cleared(obstacle_id: String)
|
||||
signal player_fell(source_id: String)
|
||||
|
||||
@export var obstacle_id := ""
|
||||
|
||||
var nerve: Node
|
||||
var mode: Node
|
||||
var _is_cleared := false
|
||||
var _prompt_layer: CanvasLayer
|
||||
var _prompt_label: Label
|
||||
|
||||
|
||||
## Registriert das Hindernis für die Kontext-Injektion der Szene.
|
||||
func _ready() -> void:
|
||||
add_to_group("gauntlet_obstacle")
|
||||
|
||||
|
||||
## Bekommt Nerven-System und Gauntlet-Modus von der Szene gereicht.
|
||||
func setup_context(nerve_system: Node, gauntlet_mode: Node) -> void:
|
||||
nerve = nerve_system
|
||||
mode = gauntlet_mode
|
||||
|
||||
|
||||
## Meldet das Hindernis einmalig als geschafft.
|
||||
func mark_cleared() -> void:
|
||||
if _is_cleared:
|
||||
return
|
||||
_is_cleared = true
|
||||
cleared.emit(obstacle_id)
|
||||
|
||||
|
||||
## Meldet einen Sturz des Spielers an diesem Hindernis.
|
||||
func report_fall() -> void:
|
||||
player_fell.emit(obstacle_id)
|
||||
|
||||
|
||||
## Liefert den Spieler oder null.
|
||||
func get_player() -> CharacterBody3D:
|
||||
return get_tree().get_first_node_in_group("player") as CharacterBody3D
|
||||
|
||||
|
||||
## Prüft, ob der Spieler gerade frei steuerbar ist (kein Dialog, kein
|
||||
## anderes Set-Piece hält ihn fest).
|
||||
func is_player_free(player: CharacterBody3D) -> bool:
|
||||
return player != null and not DialogueSystem.is_dialogue_active and not player.is_control_locked()
|
||||
|
||||
|
||||
## Baut eine begehbare Greybox-Box (Kollision + Mesh) als Kind von parent.
|
||||
func build_box(parent: Node3D, box_size: Vector3, local_position: Vector3, color: Color) -> StaticBody3D:
|
||||
var body := StaticBody3D.new()
|
||||
body.position = local_position
|
||||
var shape := CollisionShape3D.new()
|
||||
var box := BoxShape3D.new()
|
||||
box.size = box_size
|
||||
shape.shape = box
|
||||
body.add_child(shape)
|
||||
body.add_child(build_box_mesh(box_size, Vector3.ZERO, color))
|
||||
parent.add_child(body)
|
||||
return body
|
||||
|
||||
|
||||
## Baut ein reines Box-Mesh ohne Kollision (Deko/Silhouetten).
|
||||
func build_box_mesh(box_size: Vector3, local_position: Vector3, color: Color) -> MeshInstance3D:
|
||||
var mesh_instance := MeshInstance3D.new()
|
||||
var mesh := BoxMesh.new()
|
||||
mesh.size = box_size
|
||||
mesh.material = _make_material(color)
|
||||
mesh_instance.mesh = mesh
|
||||
mesh_instance.position = local_position
|
||||
return mesh_instance
|
||||
|
||||
|
||||
## Baut ein Zylinder-Mesh ohne Kollision (rotierende Stämme, Räder).
|
||||
func build_cylinder_mesh(radius: float, height: float, local_position: Vector3, color: Color) -> MeshInstance3D:
|
||||
var mesh_instance := MeshInstance3D.new()
|
||||
var mesh := CylinderMesh.new()
|
||||
mesh.top_radius = radius
|
||||
mesh.bottom_radius = radius
|
||||
mesh.height = height
|
||||
mesh.material = _make_material(color)
|
||||
mesh_instance.mesh = mesh
|
||||
mesh_instance.position = local_position
|
||||
return mesh_instance
|
||||
|
||||
|
||||
## Baut eine Trigger-Area mit Box-Shape, die nur den Spieler (Layer 2)
|
||||
## erkennt.
|
||||
func build_area(parent: Node3D, box_size: Vector3, local_position: Vector3) -> Area3D:
|
||||
var area := Area3D.new()
|
||||
area.collision_layer = 0
|
||||
area.collision_mask = 2
|
||||
area.position = local_position
|
||||
var shape := CollisionShape3D.new()
|
||||
var box := BoxShape3D.new()
|
||||
box.size = box_size
|
||||
shape.shape = box
|
||||
area.add_child(shape)
|
||||
parent.add_child(area)
|
||||
return area
|
||||
|
||||
|
||||
## Zeigt einen zentrierten Bildschirm-Prompt (baut die UI beim ersten
|
||||
## Aufruf lazy auf).
|
||||
func show_prompt(text: String) -> void:
|
||||
if _prompt_label == null:
|
||||
_build_prompt_ui()
|
||||
_prompt_label.text = text
|
||||
_prompt_label.visible = true
|
||||
|
||||
|
||||
## Blendet den Bildschirm-Prompt aus.
|
||||
func hide_prompt() -> void:
|
||||
if _prompt_label != null:
|
||||
_prompt_label.visible = false
|
||||
|
||||
|
||||
## Baut die Prompt-UI (CanvasLayer + Label, unteres Drittel).
|
||||
func _build_prompt_ui() -> void:
|
||||
_prompt_layer = CanvasLayer.new()
|
||||
_prompt_layer.layer = 3
|
||||
var root := Control.new()
|
||||
root.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
root.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
_prompt_label = Label.new()
|
||||
_prompt_label.set_anchors_preset(Control.PRESET_CENTER_BOTTOM)
|
||||
_prompt_label.position.y -= 140.0
|
||||
_prompt_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||||
_prompt_label.add_theme_font_size_override("font_size", 30)
|
||||
_prompt_label.add_theme_color_override("font_color", Color(1, 0.85, 0.4))
|
||||
_prompt_label.add_theme_color_override("font_outline_color", Color.BLACK)
|
||||
_prompt_label.add_theme_constant_override("outline_size", 8)
|
||||
_prompt_label.visible = false
|
||||
root.add_child(_prompt_label)
|
||||
_prompt_layer.add_child(root)
|
||||
add_child(_prompt_layer)
|
||||
|
||||
|
||||
## Erstellt ein einfarbiges Greybox-Material.
|
||||
func _make_material(color: Color) -> StandardMaterial3D:
|
||||
var material := StandardMaterial3D.new()
|
||||
material.albedo_color = color
|
||||
return material
|
||||
1
scripts/gameplay/obstacles/obstacle_base.gd.uid
Normal file
1
scripts/gameplay/obstacles/obstacle_base.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://cwaxvssvere1d
|
||||
59
scripts/gameplay/obstacles/rolling_log.gd
Normal file
59
scripts/gameplay/obstacles/rolling_log.gd
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
extends GauntletObstacle
|
||||
## Rolling Log (CR-002, ascent_4): rollender Stamm, Quetsch-Hazard.
|
||||
##
|
||||
## Der Stamm liegt quer zur Laufrichtung und rollt; wer auf ihm steht,
|
||||
## wird mit roll_speed entlang der Laufrichtung geschoben (roll_dir
|
||||
## bestimmt, ob bergauf oder bergab) — Tempo-Pflicht: Stillstand rollt
|
||||
## Tyrveil in den Spalt zum nächsten Stamm. Die Quetsch-Zone unterhalb
|
||||
## der Oberkante meldet crushed — dort gibt es KEINEN Seilfang
|
||||
## (no_rope_zone, Kanon: tödlichster Punkt des Laufs).
|
||||
|
||||
signal crushed
|
||||
|
||||
@export var log_length := 4.0
|
||||
@export var log_radius := 0.5
|
||||
@export var roll_dir := 1
|
||||
@export var roll_speed := 1.4
|
||||
|
||||
var _visual: MeshInstance3D
|
||||
var _was_on_log := false
|
||||
|
||||
|
||||
## Baut Lauf-Box, rollenden Zylinder (Achse quer, x) und Quetsch-Zone am
|
||||
## bergseitigen Spalt.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
build_box(self, Vector3(log_length, log_radius * 2.0, 1.0), Vector3(0, -log_radius, 0), Color(0.5, 0.4, 0.3))
|
||||
_visual = build_cylinder_mesh(log_radius + 0.05, log_length, Vector3(0, -log_radius, 0), Color(0.42, 0.33, 0.24))
|
||||
_visual.rotation.z = PI / 2.0
|
||||
add_child(_visual)
|
||||
var crush_zone := build_area(self, Vector3(log_length - 0.4, 0.9, 0.7), Vector3(0, -log_radius - 0.6, -1.0))
|
||||
crush_zone.body_entered.connect(_on_crush)
|
||||
|
||||
|
||||
## Rollt das Visual und schiebt den stehenden Spieler in Rollrichtung.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_visual.rotate_object_local(Vector3.UP, roll_speed / maxf(log_radius, 0.1) * delta * float(roll_dir))
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
var is_on_log := _is_player_on_log(player)
|
||||
if is_on_log and is_player_free(player):
|
||||
player.external_push = Vector3(0, 0, roll_speed * float(roll_dir))
|
||||
_was_on_log = true
|
||||
elif _was_on_log:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_log = false
|
||||
|
||||
|
||||
## Meldet die Quetschung zwischen zwei Stämmen (sicherer Tod, kein Seil).
|
||||
func _on_crush(body: Node3D) -> void:
|
||||
if body.is_in_group("player"):
|
||||
crushed.emit()
|
||||
|
||||
|
||||
## Prüft, ob der Spieler auf der Stamm-Oberkante steht.
|
||||
func _is_player_on_log(player: CharacterBody3D) -> bool:
|
||||
var local := to_local(player.global_position)
|
||||
return absf(local.x) < log_length / 2.0 and absf(local.z) < 0.8 \
|
||||
and local.y > -0.2 and local.y < 1.4
|
||||
1
scripts/gameplay/obstacles/rolling_log.gd.uid
Normal file
1
scripts/gameplay/obstacles/rolling_log.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://b2x6chhtnpjmg
|
||||
48
scripts/gameplay/obstacles/shaking_pillar.gd
Normal file
48
scripts/gameplay/obstacles/shaking_pillar.gd
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
extends GauntletObstacle
|
||||
## Shaking Pillar (CR-002, ascent_3): wackelnder Sprungpfeiler.
|
||||
##
|
||||
## Der ganze Pfeiler oszilliert seitlich (shake_amplitude/shake_frequency);
|
||||
## wer auf ihm steht, bekommt zusätzlich eine Drift auf external_push und
|
||||
## hält mit A/D dagegen (Balance-Prinzip aus CR-001). Das Nerven-System
|
||||
## verstärkt die Drift.
|
||||
|
||||
@export var size := Vector3(1.1, 2.2, 1.1)
|
||||
@export var shake_amplitude := 0.35
|
||||
@export var shake_frequency := 2.0
|
||||
|
||||
var _body: StaticBody3D
|
||||
var _time := 0.0
|
||||
var _was_on_pillar := false
|
||||
|
||||
|
||||
## Baut den Pfeiler; die Oberkante liegt bei position.y + size.y.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
_body = build_box(self, size, Vector3(0, size.y / 2.0, 0), Color(0.6, 0.5, 0.45))
|
||||
|
||||
|
||||
## Oszilliert den Pfeiler und lässt die Drift am stehenden Spieler zerren.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_time += delta
|
||||
var offset := sin(_time * shake_frequency * TAU) * shake_amplitude
|
||||
_body.position.x = offset
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
var is_on_pillar := _is_player_on_pillar(player)
|
||||
if is_on_pillar and is_player_free(player):
|
||||
var drift := cos(_time * shake_frequency * TAU) * shake_amplitude * shake_frequency * TAU * 0.35
|
||||
if nerve != null:
|
||||
drift *= nerve.drift_factor()
|
||||
player.external_push = Vector3(drift, 0.0, 0.0)
|
||||
_was_on_pillar = true
|
||||
elif _was_on_pillar:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_pillar = false
|
||||
|
||||
|
||||
## Prüft, ob der Spieler auf der Pfeiler-Oberkante steht.
|
||||
func _is_player_on_pillar(player: CharacterBody3D) -> bool:
|
||||
var local := to_local(player.global_position)
|
||||
return absf(local.x) < 1.1 and absf(local.z) < 1.1 \
|
||||
and local.y > size.y - 0.3 and local.y < size.y + 1.2
|
||||
1
scripts/gameplay/obstacles/shaking_pillar.gd.uid
Normal file
1
scripts/gameplay/obstacles/shaking_pillar.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://dhel3jtpu7l2l
|
||||
52
scripts/gameplay/obstacles/spinning_log.gd
Normal file
52
scripts/gameplay/obstacles/spinning_log.gd
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
extends GauntletObstacle
|
||||
## Spinning Log (CR-002, ascent_1): rotierender Balken zum Drüberlaufen.
|
||||
##
|
||||
## Die Kollision ist eine schmale Lauf-Box, der sichtbare Zylinder dreht
|
||||
## sich um die Längsachse (Laufrichtung -z). Solange der Spieler auf dem
|
||||
## Balken steht, schiebt die Drehung ihn seitlich (external_push wie beim
|
||||
## Viadukt-Wind); mit A/D bzw. Stick wird gegengehalten. Das Nerven-System
|
||||
## verstärkt die Drift. Runter = Sturz (player_fell meldet ihn dem
|
||||
## Seilfang-System).
|
||||
|
||||
@export var log_length := 4.6
|
||||
@export var log_radius := 0.35
|
||||
@export var log_spin_speed := 2.0
|
||||
|
||||
var _visual: MeshInstance3D
|
||||
var _was_on_log := false
|
||||
|
||||
|
||||
## Baut Lauf-Box und Zylinder-Visual entlang -z.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
var center := Vector3(0, log_radius, -log_length / 2.0)
|
||||
build_box(self, Vector3(0.6, log_radius * 2.0, log_length), center, Color(0.5, 0.42, 0.32))
|
||||
_visual = build_cylinder_mesh(log_radius + 0.05, log_length, center, Color(0.45, 0.36, 0.26))
|
||||
_visual.rotation.x = PI / 2.0
|
||||
add_child(_visual)
|
||||
|
||||
|
||||
## Dreht das Visual und schiebt den Spieler seitlich, solange er auf dem
|
||||
## Balken steht.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_visual.rotate_object_local(Vector3.UP, log_spin_speed * delta)
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
var is_on_log := _is_player_on_log(player)
|
||||
if is_on_log and is_player_free(player):
|
||||
var drift := log_spin_speed * log_radius
|
||||
if nerve != null:
|
||||
drift *= nerve.drift_factor()
|
||||
player.external_push = Vector3(drift, 0.0, 0.0)
|
||||
_was_on_log = true
|
||||
elif _was_on_log:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_log = false
|
||||
|
||||
|
||||
## Prüft, ob der Spieler im Lauf-Bereich über dem Balken steht.
|
||||
func _is_player_on_log(player: CharacterBody3D) -> bool:
|
||||
var local := to_local(player.global_position)
|
||||
return absf(local.x) < 0.6 and local.z < 0.4 and local.z > -log_length - 0.4 \
|
||||
and local.y > log_radius and local.y < log_radius * 2.0 + 1.4
|
||||
1
scripts/gameplay/obstacles/spinning_log.gd.uid
Normal file
1
scripts/gameplay/obstacles/spinning_log.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://mxhp56awl4s1
|
||||
109
scripts/gameplay/obstacles/spinning_wheel.gd
Normal file
109
scripts/gameplay/obstacles/spinning_wheel.gd
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
extends GauntletObstacle
|
||||
## Spinning Wheel (CR-002, ascent_1): großes, konstant drehendes Rad.
|
||||
##
|
||||
## Der Spieler springt unten in die Einstiegs-Zone, wird auf der Kreisbahn
|
||||
## (y/z-Ebene) mitgedreht und muss den Ausstieg oben timen: Sprung-Taste
|
||||
## im Fenster wheel_exit_window um den Scheitel drückt ihn auf die
|
||||
## Ausstiegs-Plattform, ein Sprung außerhalb des Fensters wirft ihn ab
|
||||
## (player_fell). Ohne Tastendruck dreht das Rad einfach weiter — die
|
||||
## nächste Umdrehung ist die nächste Chance. Zwei Dummy-Kadetten drehen
|
||||
## als Timing-Referenz sichtbar mit.
|
||||
|
||||
@export var wheel_diameter := 4.0
|
||||
@export var wheel_speed := 0.8
|
||||
@export var wheel_exit_window := 0.45
|
||||
@export var exit_platform_offset := Vector3(0, -0.3, -2.0)
|
||||
|
||||
var _pivot: Node3D
|
||||
var _is_riding := false
|
||||
var _ride_angle := 0.0
|
||||
|
||||
|
||||
## Baut Rad-Visual (Speichen + Kranz-Segmente), Dummy-Kadetten,
|
||||
## Einstiegs-Zone und Ausstiegs-Plattform.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
var radius := wheel_diameter / 2.0
|
||||
_pivot = Node3D.new()
|
||||
add_child(_pivot)
|
||||
for i in 8:
|
||||
var angle := TAU * float(i) / 8.0
|
||||
var segment := build_box_mesh(Vector3(0.5, 0.25, 1.7), Vector3(0, sin(angle) * radius, cos(angle) * radius), Color(0.5, 0.4, 0.3))
|
||||
segment.rotation.x = -angle
|
||||
_pivot.add_child(segment)
|
||||
for i in 2:
|
||||
var cadet := build_box_mesh(Vector3(0.5, 1.4, 0.5), Vector3.ZERO, Color(0.35, 0.35, 0.5))
|
||||
cadet.name = "DummyCadet%d" % (i + 1)
|
||||
_pivot.add_child(cadet)
|
||||
var entry := build_area(self, Vector3(2.0, 1.6, 1.6), Vector3(0, -radius + 0.6, 1.2))
|
||||
entry.body_entered.connect(_on_entry)
|
||||
var platform := build_box(self, Vector3(1.8, 0.4, 1.8), Vector3(exit_platform_offset.x, radius + exit_platform_offset.y, exit_platform_offset.z), Color(0.55, 0.54, 0.52))
|
||||
platform.name = "ExitPlatform"
|
||||
|
||||
|
||||
## Dreht Rad und Dummy-Kadetten; während der Fahrt wird der Spieler auf
|
||||
## der Kreisbahn geführt und der Ausstieg abgefragt.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_pivot.rotate_x(-wheel_speed * delta)
|
||||
var radius := wheel_diameter / 2.0
|
||||
_pivot.get_node("DummyCadet1").position = Vector3(0.8, sin(_ride_angle + 2.1) * (radius - 0.9), cos(_ride_angle + 2.1) * (radius - 0.9))
|
||||
_pivot.get_node("DummyCadet2").position = Vector3(-0.8, sin(_ride_angle + 4.2) * (radius - 0.9), cos(_ride_angle + 4.2) * (radius - 0.9))
|
||||
if not _is_riding:
|
||||
return
|
||||
_ride_angle += wheel_speed * delta
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
player.velocity = Vector3.ZERO
|
||||
player.global_position = to_global(Vector3(0, -cos(_ride_angle) * (radius - 1.0), sin(_ride_angle) * (radius - 1.0)))
|
||||
var is_in_window := _is_in_exit_window()
|
||||
if is_in_window:
|
||||
show_prompt("JETZT ABSPRINGEN! — Leertaste / A-Taste")
|
||||
else:
|
||||
show_prompt("Ausstieg oben timen — Leertaste / A-Taste im Fenster")
|
||||
if Input.is_action_just_pressed("jump"):
|
||||
if is_in_window:
|
||||
_finish_ride(true)
|
||||
else:
|
||||
_finish_ride(false)
|
||||
|
||||
|
||||
## Startet die Fahrt, wenn der Spieler frei in die Einstiegs-Zone springt.
|
||||
func _on_entry(body: Node3D) -> void:
|
||||
if _is_riding or not body.is_in_group("player"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
_is_riding = true
|
||||
_ride_angle = 0.2
|
||||
player.set_control_locked(true)
|
||||
|
||||
|
||||
## Beendet die Fahrt: Erfolg setzt auf die Ausstiegs-Plattform, ein
|
||||
## vertimter Absprung wirft den Spieler ab.
|
||||
func _finish_ride(is_success: bool) -> void:
|
||||
_is_riding = false
|
||||
hide_prompt()
|
||||
var player := get_player()
|
||||
player.set_control_locked(false)
|
||||
if is_success:
|
||||
var radius := wheel_diameter / 2.0
|
||||
player.global_position = to_global(Vector3(exit_platform_offset.x, radius + exit_platform_offset.y + 0.4, exit_platform_offset.z))
|
||||
player.velocity = Vector3.ZERO
|
||||
mark_cleared()
|
||||
else:
|
||||
player.velocity = Vector3(2.0, 1.0, 0.0)
|
||||
report_fall()
|
||||
|
||||
|
||||
## Prüft, ob die Fahrt gerade im Ausstiegs-Fenster um den Rad-Scheitel ist.
|
||||
func _is_in_exit_window() -> bool:
|
||||
var apex_phase := fposmod(_ride_angle, TAU)
|
||||
var window_half := wheel_speed * wheel_exit_window / 2.0
|
||||
return absf(apex_phase - PI) < maxf(window_half, 0.12)
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade im Rad mitfährt (für Tests).
|
||||
func is_riding() -> bool:
|
||||
return _is_riding
|
||||
1
scripts/gameplay/obstacles/spinning_wheel.gd.uid
Normal file
1
scripts/gameplay/obstacles/spinning_wheel.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://yr8ljgmk6wdl
|
||||
51
scripts/gameplay/obstacles/vertical_ramp.gd
Normal file
51
scripts/gameplay/obstacles/vertical_ramp.gd
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
extends GauntletObstacle
|
||||
## Vertical Ramp (CR-002, ascent_5): steile Holzrampe zum Hochsprinten.
|
||||
##
|
||||
## Die Rampe ist begehbar, drückt aber bergab: Nur mit Sprint-Momentum
|
||||
## (ramp_min_momentum) kommt Tyrveil dagegen an, im Gehen rutscht sie
|
||||
## zurück. Greybox über external_push hangabwärts, solange der Spieler
|
||||
## ohne ausreichendes Tempo auf der Rampe steht.
|
||||
|
||||
@export var ramp_height := 3.0
|
||||
@export var ramp_length := 3.6
|
||||
@export var ramp_min_momentum := 5.0
|
||||
@export var slide_back_push := 3.0
|
||||
|
||||
var _ramp: StaticBody3D
|
||||
var _was_on_ramp := false
|
||||
|
||||
|
||||
## Baut die geneigte Holzfläche (Fuß bei z=0, Kopf bei -ramp_length).
|
||||
func _ready() -> void:
|
||||
super()
|
||||
var slope := atan2(ramp_height, ramp_length)
|
||||
var surface_length := sqrt(ramp_height * ramp_height + ramp_length * ramp_length)
|
||||
_ramp = build_box(self, Vector3(1.8, 0.3, surface_length + 0.6), Vector3(0, ramp_height / 2.0, -ramp_length / 2.0), Color(0.6, 0.45, 0.3))
|
||||
_ramp.rotation.x = -slope
|
||||
|
||||
|
||||
## Drückt langsame Spieler die Rampe hinunter; Sprint-Momentum hält an.
|
||||
func _physics_process(_delta: float) -> void:
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
var is_on_ramp := _is_player_on_ramp(player)
|
||||
if is_on_ramp and is_player_free(player):
|
||||
var speed := Vector3(player.velocity.x, 0, player.velocity.z).length()
|
||||
if speed < ramp_min_momentum:
|
||||
player.external_push = Vector3(0, 0, slide_back_push)
|
||||
else:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_ramp = true
|
||||
elif _was_on_ramp:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_ramp = false
|
||||
|
||||
|
||||
## Prüft, ob der Spieler auf der Rampenfläche steht.
|
||||
func _is_player_on_ramp(player: CharacterBody3D) -> bool:
|
||||
var local := to_local(player.global_position)
|
||||
if absf(local.x) > 1.0 or local.z > 0.3 or local.z < -ramp_length - 0.3:
|
||||
return false
|
||||
var expected_y := ramp_height * clampf(-local.z / ramp_length, 0.0, 1.0)
|
||||
return local.y > expected_y - 0.4 and local.y < expected_y + 1.4
|
||||
1
scripts/gameplay/obstacles/vertical_ramp.gd.uid
Normal file
1
scripts/gameplay/obstacles/vertical_ramp.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://cga1pwncectjm
|
||||
Loading…
Add table
Add a link
Reference in a new issue