Autoren-Befund: „die Stangen wo man A/D druecken muss gehen nicht, ich drueck a oder d und ich fall" — und sie ergaben eine lange Wurst statt paralleler Stangen. - Geometrie: statt drei Schienen Ende-an-Ende (ein durchgehender, pro Segment hoeher werdender Balken) jetzt rung_count parallele Sprossen quer zur Laufrichtung, gleichmaessig verteilt (Monkey Bars). - Mechanik entschaerft: Die falsche Hand wird ignoriert (kein Sturz), die korrekte Wechsel-Hand zieht eine Sprosse weiter. Sturz nur noch, wenn man zu lange an derselben Sprosse haengt (hangel_rhythm_window). Vorher stuerzte JEDER falsche/zu langsame Tap sofort ab. Verifikation: Headless-Probe (parallele kurze Sprossen, Greifen haengt, falsche Hand kein Sturz/kein Vorruecken, korrekte Hand rueckt vor, Stillstand faellt), Boot-Check gauntlet/terrace_3 0 Fehler. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
116 lines
3.8 KiB
GDScript
116 lines
3.8 KiB
GDScript
extends GauntletObstacle
|
||
## Iron Rails (CR-002, ascent_3): parallele Sprossen zum Hangeln (Monkey Bars).
|
||
##
|
||
## Waagerechte Sprossen quer zur Laufrichtung, gleichmäßig entlang der
|
||
## Strecke verteilt (`rung_count` × `rung_spacing`) — **parallel zueinander,
|
||
## KEIN durchgehender Balken.** Der Spieler springt an die erste Sprosse,
|
||
## hängt darunter und hangelt Hand über Hand weiter: A und D (bzw. LB/RB) im
|
||
## Wechsel. Ein korrekter Wechsel-Tap zieht eine Sprosse weiter.
|
||
##
|
||
## **Nachsichtig (Testbarkeit):** Die falsche Hand wird ignoriert (KEIN
|
||
## Sturz) — nur wer zu lange an derselben Sprosse hängt, reißt den Rhythmus
|
||
## und fällt (`hangel_rhythm_window`). Früher stürzte jeder falsche Tap
|
||
## sofort ab, was das Hindernis praktisch unpassierbar machte. Am Ende lässt
|
||
## Tyrveil sich auf den Lande-Absatz fallen (`drop_target`).
|
||
|
||
const RUNG_COLOR := Color(0.35, 0.35, 0.4)
|
||
const HANG_DROP := 1.75
|
||
const GRAB_LOCAL_Z := 0.4
|
||
|
||
@export var rung_count := 11
|
||
@export var rung_spacing := 1.1
|
||
@export var rung_width := 1.5
|
||
@export var rail_base_height := 2.6
|
||
@export var hangel_rhythm_window := 1.4
|
||
@export var drop_target := Vector3(0, 1.4, -12.8)
|
||
|
||
var _is_hanging := false
|
||
var _rung := 0
|
||
var _expected_dir := -1
|
||
var _rhythm_timer := 0.0
|
||
|
||
|
||
## Baut die parallelen Sprossen und die Greif-Zone am Anfang.
|
||
func _ready() -> void:
|
||
super()
|
||
for i in rung_count:
|
||
add_child(build_box_mesh(Vector3(rung_width, 0.12, 0.12), Vector3(0, rail_base_height, -_rung_z(i)), RUNG_COLOR))
|
||
var grab := build_area(self, Vector3(rung_width + 0.4, 1.8, 1.2), Vector3(0, rail_base_height - 1.0, -GRAB_LOCAL_Z))
|
||
grab.body_entered.connect(_on_grab)
|
||
add_world_prompt(Vector3(0, rail_base_height + 0.6, -GRAB_LOCAL_Z), "hangel_left", "/%s Hangeln" % InputPrompts.label("hangel_right"))
|
||
|
||
|
||
## Führt den hängenden Spieler von Sprosse zu Sprosse 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
|
||
player.velocity = Vector3.ZERO
|
||
player.global_position = to_global(Vector3(0, rail_base_height - HANG_DROP, -_rung_z(_rung)))
|
||
_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: String = InputPrompts.prompt("hangel_left") if _expected_dir < 0 else InputPrompts.prompt("hangel_right")
|
||
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 != _expected_dir:
|
||
return
|
||
_expected_dir = -_expected_dir
|
||
_rhythm_timer = 0.0
|
||
_rung += 1
|
||
if _rung >= rung_count:
|
||
_finish(player)
|
||
|
||
|
||
## Lokale z-Position der i-ten Sprosse (nach -z verteilt).
|
||
func _rung_z(i: int) -> float:
|
||
return rung_spacing * float(i + 1)
|
||
|
||
|
||
## Hängt den Spieler an die erste Sprosse, 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
|
||
_rung = 0
|
||
_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 (zu lange an derselben Sprosse): 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
|