windgeschworen/scripts/gameplay/obstacles/iron_rail.gd
danny dfb791ddb3 Gauntlet-Hangeln (IronRail): parallele Sprossen + nachsichtiges Hangeln
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>
2026-07-29 06:53:09 +02:00

116 lines
3.8 KiB
GDScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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