CR-Paket: Rad flach + tastenlos, Kugel-Griff gefixt, Seil-Prioritaet, dynamische Button-Prompts

- spinning_wheel: flache Dreh-Scheibe im Laufweg statt aufrechter
  Trommel; Interaktion rein ueber Hitbox (drauflaufen, kein Tastendruck):
  Drehung reisst tangential mit (A/D gegenhalten), fehlendes Tortenstueck
  laesst am Boden durchfallen (im Sprung uebersprungen), Nabe sicher,
  Ausstiegs-Zone meldet den Uebergang
- buoy_ball: Greifen von body_entered-Events auf Abstands-Polling
  umgestellt (Events feuerten nicht, wenn der Spieler schon im Bereich
  stand -> Kugeln waren nicht greifbar); grab_radius-Export,
  Wiedergreif-Sperre 1,5 s nach jedem Loslassen gegen sofortiges
  Wieder-Einsammeln durch dieselbe Kugel
- safety_rope_field: Fang nur bei echtem Sturz (Fall unter -7 m/s UND
  Sturzkorridor oder >3 m unter letzter Standhoehe) - kurze Huepfer
  loesen kein Greif-Fenster mehr aus; keine Eingabe-Kollision Rad/Seil
- InputPrompts-Autoload implementiert (war Skelett): erkennt Tastatur
  vs. Xbox/PlayStation am letzten Input-Event bzw. Joypad-Namen,
  liefert Action-Labels ([E]/[Leertaste] vs. [A]/[LB] vs. [Kreuz]/[L1]),
  device_changed fuer Live-Umschaltung; Welt-Prompts (Label3D) an
  Kugeln/Schienen/Kamin, Bildschirm-Prompts nutzen dynamische Labels
- gravel_curve.gd nachcommittet (fehlte in V.0.6.1, wird von der
  Gauntlet-Szene referenziert)
- Verifikation: Headless-Sonde komplett gruen (70+ Checks inkl. neuer
  Rad-/Kugel-/Seil-/Prompt-Tests), Boot-Check aller 6 Szenen fehlerfrei
- v1-Ausbau (10-Tage-Zyklus) bleibt als Phasen-Programm in
  CHANGEREQUESTS.md, Fix-CRs nach CHANGEREQUESTS_DONE.md uebertragen

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-07-11 18:12:13 +02:00
parent bc410156ee
commit 1a2c1be65d
15 changed files with 654 additions and 221 deletions

View file

@ -1,18 +1,17 @@
extends GauntletObstacle
## Spinning Wheel als geschlossene Trommel (CR-003 §3b).
## Spinning Wheel als flache Dreh-Scheibe (CR Gameplay-Fixes: das Rad
## liegt flach auf dem Boden, Interaktion rein über Hitbox — kein
## Tastendruck zum Starten).
##
## Die Trommel steht mit der Radebene parallel zur Felswand (Achse zeigt
## in die Wand); die äußere Haut ist durchgehend bis auf genau eine Lücke
## (wheel_gap_arc). Ablauf: (1) seitlich durch die Lücke einspringen,
## wenn sie an der Einstiegsseite vorbeikommt (wheel_entry_window),
## (2) innen auf der Trommel-Innenfläche mitlaufen — die Drehung trägt
## den Läufer sonst die Wand hoch (wheel_carry_force, A/D hält dagegen),
## (3) wandert die Lücke unter den Füßen durch, rechtzeitig darüber
## springen (gap_jump_window), sonst fällt er durch die Trommel,
## (4) an der gegenüberliegenden Seite im Fenster wheel_exit_window durch
## die Lücke hinausspringen. Zwei Dummy-Kadetten laufen sichtbar mit
## (Timing-Referenz). Ein vertimter Einsprung prallt an der Haut ab
## (Rückstoß, kein Tod); Fehler INNEN sind Stürze (player_fell).
## Die Scheibe liegt flach im Laufweg und dreht sich konstant um die
## Hochachse. Wer sie betritt (einfach hineinlaufen), wird von der
## Drehung tangential mitgerissen (wheel_carry_force, mit A/D bzw. Stick
## gegenhalten und weiterlaufen). Ein Tortenstück der Scheibe fehlt
## (wheel_gap_arc): Wandert die Lücke unter die Füße, fällt der Läufer
## durch — es sei denn, er ist gerade im Sprung darüber. Die Nabe in der
## Mitte ist durchgehend sicher. Am gegenüberliegenden Rand meldet eine
## Ausstiegs-Zone den geschafften Übergang. Zwei Dummy-Kadetten drehen
## als Timing-Referenz sichtbar mit.
signal wheel_entered
signal wheel_gap_cleared
@ -22,184 +21,118 @@ signal wheel_exited
@export var wheel_speed := 0.8
@export var wheel_dir := 1
@export var wheel_gap_arc := 1.0
@export var wheel_entry_window := 0.6
@export var gap_jump_window := 0.6
@export var wheel_exit_window := 0.5
@export var wheel_carry_force := 0.35
@export var carry_limit := 0.9
@export var wheel_carry_force := 1.0
@export var hub_radius := 0.7
var _pivot: Node3D
var _dummy1: MeshInstance3D
var _dummy2: MeshInstance3D
var _is_riding := false
var _is_in_entry_zone := false
var _player_angle := 0.0
var _hop_timer := 0.0
var _has_cleared_pass := false
var _was_on_disc := false
var _has_entered := false
var _has_exited := false
var _was_gap_near := false
var _time := 0.0
## Baut Haut-Segmente (mit Lücke), Nabe, Dummy-Kadetten, Einstiegs-Zone
## und Ausstiegs-Plattform.
## Baut Scheiben-Segmente (mit Lücke), Nabe, Kollisions-Scheibe,
## Dummy-Kadetten und die Ausstiegs-Zone.
func _ready() -> void:
super()
var radius := wheel_diameter / 2.0
var body := StaticBody3D.new()
var shape := CollisionShape3D.new()
var cylinder := CylinderShape3D.new()
cylinder.radius = radius
cylinder.height = 0.5
shape.shape = cylinder
shape.position = Vector3(0, -0.25, 0)
body.add_child(shape)
add_child(body)
_pivot = Node3D.new()
add_child(_pivot)
var gap_half := wheel_gap_arc / 2.0
var segment_count := 14
var segment_count := 12
var arc := TAU - wheel_gap_arc
for i in segment_count:
var angle := gap_half + arc * (float(i) + 0.5) / float(segment_count)
var segment := build_box_mesh(Vector3(arc / float(segment_count) * radius + 0.12, 0.3, 1.7), Vector3(sin(angle) * radius, -cos(angle) * radius, 0), Color(0.5, 0.4, 0.3))
segment.rotation.z = angle
var segment := build_box_mesh(Vector3(arc / float(segment_count) * radius * 0.75, 0.15, radius - hub_radius + 0.1), Vector3(sin(angle) * (radius + hub_radius) / 2.0, 0.08, cos(angle) * (radius + hub_radius) / 2.0), Color(0.5, 0.4, 0.3))
segment.rotation.y = angle
_pivot.add_child(segment)
add_child(build_box_mesh(Vector3(0.5, 0.5, 2.0), Vector3.ZERO, Color(0.35, 0.3, 0.25)))
_dummy1 = build_box_mesh(Vector3(0.45, 1.3, 0.45), Vector3.ZERO, Color(0.35, 0.35, 0.5))
add_child(_dummy1)
_dummy2 = build_box_mesh(Vector3(0.45, 1.3, 0.45), Vector3.ZERO, Color(0.3, 0.4, 0.45))
add_child(_dummy2)
var entry := build_area(self, Vector3(1.8, 2.0, 2.0), Vector3(-radius - 1.0, -radius + 1.0, 0))
entry.body_entered.connect(_on_entry_zone_entered)
entry.body_exited.connect(_on_entry_zone_exited)
build_box(self, Vector3(1.8, 0.5, 1.8), Vector3(radius + 1.4, -radius + 0.25, 0), Color(0.55, 0.54, 0.52))
var hub := build_cylinder_mesh(hub_radius, 0.2, Vector3(0, 0.1, 0), Color(0.35, 0.3, 0.25))
_pivot.add_child(hub)
var dummy1 := build_box_mesh(Vector3(0.45, 1.3, 0.45), Vector3(sin(1.2) * 1.4, 0.75, cos(1.2) * 1.4), Color(0.35, 0.35, 0.5))
_pivot.add_child(dummy1)
var dummy2 := build_box_mesh(Vector3(0.45, 1.3, 0.45), Vector3(sin(3.6) * 1.4, 0.75, cos(3.6) * 1.4), Color(0.3, 0.4, 0.45))
_pivot.add_child(dummy2)
var exit_zone := build_area(self, Vector3(1.2, 2.2, 2.4), Vector3(radius + 0.7, 1.0, 0))
exit_zone.body_entered.connect(_on_exit_zone)
## Merkt, dass der Spieler in der Einstiegs-Zone steht.
func _on_entry_zone_entered(body: Node3D) -> void:
if body.is_in_group("player"):
_is_in_entry_zone = true
## Merkt, dass der Spieler die Einstiegs-Zone verlassen hat.
func _on_entry_zone_exited(body: Node3D) -> void:
if body.is_in_group("player"):
_is_in_entry_zone = false
if not _is_riding:
hide_prompt()
## Dreht die Trommel, positioniert Dummy-Kadetten und treibt Einstieg,
## Mitlaufen, Lücken-Sprung und Ausstieg an.
## Dreht die Scheibe und wendet Mitreiß-Kraft, Lücken-Logik und
## Betreten-Erkennung auf den Läufer an.
func _physics_process(delta: float) -> void:
_time += delta
_pivot.rotate_z(wheel_speed * float(wheel_dir) * delta)
var radius := wheel_diameter / 2.0
var inner := radius - 0.55
_dummy1.position = Vector3(sin(0.55 + sin(_time * 2.0) * 0.08) * inner, -cos(0.55) * inner + 0.65, 0.4)
_dummy2.position = Vector3(sin(-0.5 + sin(_time * 1.7) * 0.08) * inner, -cos(-0.5) * inner + 0.65, -0.4)
_pivot.rotate_y(wheel_speed * float(wheel_dir) * delta)
var player := get_player()
if player == null:
return
if _is_riding:
_process_ride(player, delta, inner)
else:
_process_entry(player)
## Einstieg: In der Zone warten, bis die Lücke links vorbeikommt, dann
## Leertaste; vertimter Sprung prallt an der Haut ab.
func _process_entry(player: CharacterBody3D) -> void:
if not _is_in_entry_zone or not is_player_free(player):
return
var is_gap_at_entry := _angle_distance(_gap_angle(), -PI / 2.0) < _window_tolerance(wheel_entry_window)
if is_gap_at_entry:
show_prompt("JETZT: durch die Lücke! — Leertaste / A-Taste")
else:
show_prompt("Warten, bis die Lücke links ist — Leertaste / A-Taste")
if not Input.is_action_just_pressed("jump"):
return
hide_prompt()
if is_gap_at_entry:
_is_riding = true
_player_angle = 0.0
_hop_timer = 0.0
_has_cleared_pass = false
player.set_control_locked(true)
wheel_entered.emit()
else:
player.velocity = global_transform.basis.x * -3.0 + Vector3(0, 2.0, 0)
## Fahrt in der Trommel: Mitlaufen gegen die Drehung, Lücke überspringen,
## Ausstieg an der Gegenseite timen.
func _process_ride(player: CharacterBody3D, delta: float, inner: float) -> void:
_hop_timer = maxf(_hop_timer - delta, 0.0)
_player_angle += wheel_speed * float(wheel_dir) * wheel_carry_force * delta
_player_angle += Input.get_axis("move_left", "move_right") * 1.1 * delta
player.velocity = Vector3.ZERO
player.global_position = to_global(Vector3(sin(_player_angle) * inner, -cos(_player_angle) * inner, 0))
if absf(_player_angle) > carry_limit:
_fail_ride(player, Vector3(0, 2.0, 0))
return
var gap := _gap_angle()
var gap_half := wheel_gap_arc / 2.0
var is_gap_under := _angle_distance(gap, _player_angle) < gap_half * 0.7
var is_exit_window := _angle_distance(gap, PI / 2.0) < _window_tolerance(wheel_exit_window)
if is_gap_under:
if _hop_timer > 0.0 or _has_cleared_pass:
if not _has_cleared_pass:
_has_cleared_pass = true
wheel_gap_cleared.emit()
else:
player.global_position = to_global(Vector3(sin(_player_angle) * (inner + 0.8), -cos(_player_angle) * (inner + 0.8), 0))
_fail_ride(player, Vector3(0, -6.5, 0))
return
else:
_has_cleared_pass = false
if is_exit_window:
show_prompt("AUSSTIEG rechts: durch die Lücke! — Leertaste / A-Taste")
elif _angle_distance(gap, _player_angle) < gap_half + 0.6:
show_prompt("Die Lücke kommt: DRÜBERSPRINGEN — Leertaste / A-Taste")
else:
show_prompt("Mitlaufen: A/D bzw. Stick gegen die Drehung")
if Input.is_action_just_pressed("jump"):
if is_exit_window:
_finish_ride(player)
else:
_hop_timer = gap_jump_window
## Erfolgreicher Ausstieg durch die Lücke auf die Plattform dahinter.
func _finish_ride(player: CharacterBody3D) -> void:
_is_riding = false
hide_prompt()
player.set_control_locked(false)
var local := to_local(player.global_position)
var radial := Vector2(local.x, local.z)
var radius := wheel_diameter / 2.0
player.global_position = to_global(Vector3(radius + 1.4, -radius + 1.0, 0))
player.velocity = Vector3.ZERO
wheel_exited.emit()
var is_on_disc := radial.length() < radius - 0.1 and local.y > -0.3 and local.y < 1.6
if not is_on_disc:
if _was_on_disc:
player.external_push = Vector3.ZERO
_was_on_disc = false
return
if not is_player_free(player):
return
if not _has_entered:
_has_entered = true
wheel_entered.emit()
_was_on_disc = true
var spin := wheel_speed * float(wheel_dir) * wheel_carry_force
var push := Vector3(local.z * spin, 0.0, -local.x * spin)
if nerve != null:
push *= nerve.drift_factor()
player.external_push = global_transform.basis * push
_process_gap(player, local, radial)
## Prüft, ob die Lücke unter dem Läufer durchzieht: Am Boden fällt er
## durch, im Sprung darüber gilt sie als übersprungen. Die Nabe ist safe.
func _process_gap(player: CharacterBody3D, local: Vector3, radial: Vector2) -> void:
if radial.length() < hub_radius + 0.2:
_was_gap_near = false
return
var player_angle := atan2(local.x, local.z)
var gap_center := wrapf(_pivot.rotation.y, -PI, PI)
var distance := absf(wrapf(player_angle - gap_center, -PI, PI))
var is_gap_under := distance < wheel_gap_arc / 2.0 * 0.8
if is_gap_under:
if player.is_on_floor():
player.external_push = Vector3.ZERO
player.global_position = to_global(Vector3(local.x, -0.8, local.z))
player.velocity = Vector3(0, -6.5, 0)
_was_on_disc = false
_was_gap_near = false
report_fall()
return
if not _was_gap_near:
_was_gap_near = true
wheel_gap_cleared.emit()
else:
_was_gap_near = false
## Ausstiegs-Zone hinter der Scheibe erreicht: Übergang geschafft.
func _on_exit_zone(body: Node3D) -> void:
if not body.is_in_group("player"):
return
if not _has_exited:
_has_exited = true
wheel_exited.emit()
mark_cleared()
## Sturz in der Trommel (mitgerissen oder durch die Lücke gefallen).
func _fail_ride(player: CharacterBody3D, exit_velocity: Vector3) -> void:
_is_riding = false
hide_prompt()
player.set_control_locked(false)
player.velocity = exit_velocity
report_fall()
## Aktuelle Welt-Winkelposition der Lücke (0 = unten, +pi/2 = rechts).
func _gap_angle() -> float:
return wrapf(_pivot.rotation.z, -PI, PI)
## Toleranz eines Zeitfensters als Winkel (skaliert mit der Drehung und
## dem manipulated-Fenster des Modus).
func _window_tolerance(window: float) -> float:
var scaled := window
if mode != null:
scaled *= mode.window_scale()
return maxf(wheel_gap_arc * 0.4 + wheel_speed * scaled * 0.5, 0.2)
## Kleinste Winkeldistanz zweier Winkel.
func _angle_distance(a: float, b: float) -> float:
return absf(wrapf(a - b, -PI, PI))
## Meldet, ob der Spieler gerade in der Trommel mitfährt (für Tests).
## Meldet, ob der Läufer gerade auf der Scheibe steht (für Tests).
func is_riding() -> bool:
return _is_riding
return _was_on_disc