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:
parent
bc410156ee
commit
1a2c1be65d
15 changed files with 654 additions and 221 deletions
86
scripts/gameplay/gravel_curve.gd
Normal file
86
scripts/gameplay/gravel_curve.gd
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
extends Node3D
|
||||
## Kies-Kurve zwischen zwei Terrassen (CR-003).
|
||||
##
|
||||
## Eine schulterbreite Serpentinen-Kehre am Terrassen-Ende: Sie schwingt
|
||||
## über den Sturzkorridor hinaus (Sichtlinie auf stürzende Rivalen),
|
||||
## steigt über zwei Rampen und eine Wende-Plattform um height_gain und
|
||||
## mündet auf der nächsten Terrasse. Echte Laufwege mit Zeitanteil im
|
||||
## Ernstlauf und Rast-Zone (Griff-Erholung) im Training wie im Lauf.
|
||||
## side spiegelt die Kurve für linke Terrassen-Enden. exit_reached feuert,
|
||||
## wenn Tyrveil oben ankommt (Checkpoint/Story-Hook übernimmt die Szene).
|
||||
|
||||
signal exit_reached
|
||||
|
||||
@export var height_gain := 6.0
|
||||
@export var side := 1
|
||||
@export var curve_length := 4.0
|
||||
@export var curve_width := 0.9
|
||||
|
||||
var _has_fired := false
|
||||
|
||||
|
||||
## Baut Einstiegs-Plattform, Hinauf-Rampe, Wende-Plattform, Rück-Rampe,
|
||||
## Ausstiegs-Plattform sowie Rast- und Ausstiegs-Zone.
|
||||
func _ready() -> void:
|
||||
var h := height_gain
|
||||
var out_z := curve_length + 0.6
|
||||
_build_walk_box(Vector3(2.0, 0.3, 2.4), Vector3(0, -0.15, 0), 0.0)
|
||||
var slope := atan2(h / 2.0, out_z - 0.7)
|
||||
var ramp_length := sqrt(pow(h / 2.0, 2.0) + pow(out_z - 0.7, 2.0)) + 0.6
|
||||
_build_walk_box(Vector3(curve_width, 0.25, ramp_length), Vector3(-0.6 * float(side), h * 0.25, out_z / 2.0 + 0.2), -slope)
|
||||
_build_walk_box(Vector3(2.6, 0.3, 1.5), Vector3(0.4 * float(side), h * 0.5 - 0.15, out_z + 0.7), 0.0)
|
||||
_build_walk_box(Vector3(curve_width, 0.25, ramp_length), Vector3(1.5 * float(side), h * 0.75, out_z / 2.0 + 0.2), slope)
|
||||
_build_walk_box(Vector3(3.2, 0.3, 2.0), Vector3(0.4 * float(side), h - 0.15, -0.3), 0.0)
|
||||
var rest := _build_zone(Vector3(4.6, h + 3.0, out_z + 3.0), Vector3(0.4 * float(side), h * 0.5 + 1.0, out_z / 2.0))
|
||||
rest.add_to_group("gauntlet_rest")
|
||||
var exit_zone := _build_zone(Vector3(3.2, 2.2, 2.0), Vector3(0.4 * float(side), h + 1.1, -0.3))
|
||||
exit_zone.body_entered.connect(_on_exit_entered)
|
||||
|
||||
|
||||
## Liefert die Welt-Position des Kurven-Ausstiegs (Respawn-Punkt).
|
||||
func get_exit_position() -> Vector3:
|
||||
return to_global(Vector3(0.4 * float(side), height_gain + 0.2, -0.3))
|
||||
|
||||
|
||||
## Meldet das Erreichen des Ausstiegs einmalig.
|
||||
func _on_exit_entered(body: Node3D) -> void:
|
||||
if _has_fired or not body.is_in_group("player"):
|
||||
return
|
||||
_has_fired = true
|
||||
exit_reached.emit()
|
||||
|
||||
|
||||
## Baut ein begehbares Kurven-Stück (Kollision + Mesh), optional geneigt.
|
||||
func _build_walk_box(box_size: Vector3, local_position: Vector3, tilt: float) -> void:
|
||||
var body := StaticBody3D.new()
|
||||
body.position = local_position
|
||||
body.rotation.x = tilt
|
||||
var shape := CollisionShape3D.new()
|
||||
var box := BoxShape3D.new()
|
||||
box.size = box_size
|
||||
shape.shape = box
|
||||
body.add_child(shape)
|
||||
var mesh_instance := MeshInstance3D.new()
|
||||
var mesh := BoxMesh.new()
|
||||
mesh.size = box_size
|
||||
var material := StandardMaterial3D.new()
|
||||
material.albedo_color = Color(0.62, 0.58, 0.5)
|
||||
mesh.material = material
|
||||
mesh_instance.mesh = mesh
|
||||
body.add_child(mesh_instance)
|
||||
add_child(body)
|
||||
|
||||
|
||||
## Baut eine Trigger-Zone (nur Spieler-Layer).
|
||||
func _build_zone(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)
|
||||
add_child(area)
|
||||
return area
|
||||
1
scripts/gameplay/gravel_curve.gd.uid
Normal file
1
scripts/gameplay/gravel_curve.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://c1xisrsoc2sat
|
||||
|
|
@ -14,13 +14,14 @@ extends GauntletObstacle
|
|||
@export var launch_window := 0.5
|
||||
@export var momentum_charge_time := 0.9
|
||||
@export var launch_target := Vector3(0, 1.2, -2.6)
|
||||
@export var grab_radius := 2.8
|
||||
|
||||
var _ball: MeshInstance3D
|
||||
var _grab_area: Area3D
|
||||
var _time := 0.0
|
||||
var _is_holding := false
|
||||
var _charge := 0.0
|
||||
var _was_charging := false
|
||||
var _regrab_cooldown := 0.0
|
||||
|
||||
|
||||
## Baut Kugel, Seil-Visual und Greif-Zone.
|
||||
|
|
@ -34,45 +35,47 @@ func _ready() -> void:
|
|||
_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)
|
||||
add_world_prompt(Vector3(0, 1.1, 0), "swing_charge", "Schwung")
|
||||
|
||||
|
||||
## 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
|
||||
_regrab_cooldown = maxf(_regrab_cooldown - delta, 0.0)
|
||||
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
|
||||
if not _is_holding:
|
||||
_try_grab(player)
|
||||
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))
|
||||
show_prompt("Schwung laden: %d%% — im Scheitel %s loslassen" % [int(_charge * 100.0), InputPrompts.prompt("swing_charge")])
|
||||
elif _was_charging:
|
||||
_release(player)
|
||||
else:
|
||||
show_prompt("Leertaste / A-Taste HALTEN — Schwung laden")
|
||||
show_prompt("%s HALTEN — Schwung laden" % InputPrompts.prompt("swing_charge"))
|
||||
_was_charging = is_charging
|
||||
|
||||
|
||||
## Klammert den Spieler an die Kugel, wenn er frei in die Greif-Zone
|
||||
## kommt; der Abstands-Check fängt veraltete Zonen-Events der pendelnden
|
||||
## Kugel ab (z. B. nach einem Respawn quer über die Terrasse).
|
||||
func _on_grab(body: Node3D) -> void:
|
||||
if _is_holding or not body.is_in_group("player"):
|
||||
## Greift per Abstands-Polling statt Zonen-Events (CR Kollision/Greifen):
|
||||
## Sobald der freie Spieler nah genug an der Kugel und nicht über ihr
|
||||
## ist, klammert er sich fest — egal ob er hineinspringt, hineinfällt
|
||||
## oder schon im Bereich stand. Die Wiedergreif-Sperre verhindert, dass
|
||||
## dieselbe Kugel den gerade gelösten Spieler sofort wieder einsammelt.
|
||||
func _try_grab(player: CharacterBody3D) -> void:
|
||||
if _regrab_cooldown > 0.0 or not is_player_free(player):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
var local := to_local(player.global_position)
|
||||
if local.y > _ball.position.y + 0.6:
|
||||
return
|
||||
if to_local(player.global_position).distance_to(_ball.position) > 3.0:
|
||||
if local.distance_to(_ball.position) > grab_radius:
|
||||
return
|
||||
_is_holding = true
|
||||
_charge = 0.0
|
||||
|
|
@ -84,6 +87,7 @@ func _on_grab(body: Node3D) -> void:
|
|||
## Ziel, sonst zu kurz -> Sturz.
|
||||
func _release(player: CharacterBody3D) -> void:
|
||||
_is_holding = false
|
||||
_regrab_cooldown = 1.5
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
if _charge >= 1.0 and _is_in_launch_window():
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ func _ready() -> void:
|
|||
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)
|
||||
add_world_prompt(Vector3(0, rail_base_height + 0.6, -0.4), "hangel_left", "/%s Hangeln" % InputPrompts.label("hangel_right"))
|
||||
|
||||
|
||||
## Führt den hängenden Spieler und wertet den Hangel-Rhythmus aus.
|
||||
|
|
@ -52,7 +53,7 @@ func _physics_process(delta: float) -> void:
|
|||
if _rhythm_timer > window:
|
||||
_fail(player)
|
||||
return
|
||||
var next_hand := "A / LB" if _expected_dir < 0 else "D / RB"
|
||||
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"):
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ func _ready() -> void:
|
|||
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)
|
||||
add_world_prompt(Vector3(0, 2.2, -1.0), "move_forward", "Spreizen")
|
||||
|
||||
|
||||
## Treibt den Spreiz-Modus: Drift auf die Balance, A/D hält dagegen,
|
||||
|
|
@ -51,7 +52,7 @@ func _physics_process(delta: float) -> void:
|
|||
if absf(_balance) > chimney_brace_tolerance:
|
||||
_slip(player)
|
||||
return
|
||||
show_prompt("X-SPREIZ — W/Stick hoch: Stufe · A/D: Druck halten [%s]" % _balance_bar())
|
||||
show_prompt("X-SPREIZ — %s: Stufe · %s/%s: Druck halten [%s]" % [InputPrompts.prompt("move_forward"), InputPrompts.label("move_left"), InputPrompts.label("move_right"), _balance_bar()])
|
||||
if Input.is_action_just_pressed("move_forward"):
|
||||
_height += step_height
|
||||
_drift_dir = 1.0 if randf() < 0.5 else -1.0
|
||||
|
|
|
|||
|
|
@ -110,6 +110,24 @@ func build_area(parent: Node3D, box_size: Vector3, local_position: Vector3) -> A
|
|||
return area
|
||||
|
||||
|
||||
## Hängt einen Welt-Prompt (Label3D-Billboard) an das Hindernis, der die
|
||||
## Taste der Action für das aktive Eingabegerät zeigt (z. B. "[E] Öffnen"
|
||||
## bzw. "[✕] Öffnen") und bei Gerätewechsel live umschaltet.
|
||||
func add_world_prompt(local_position: Vector3, action: String, suffix: String) -> Label3D:
|
||||
var label := Label3D.new()
|
||||
label.billboard = BaseMaterial3D.BILLBOARD_ENABLED
|
||||
label.font_size = 44
|
||||
label.outline_size = 12
|
||||
label.modulate = Color(1, 0.9, 0.5)
|
||||
label.position = local_position
|
||||
add_child(label)
|
||||
var update := func() -> void:
|
||||
label.text = "%s %s" % [InputPrompts.prompt(action), suffix]
|
||||
update.call()
|
||||
InputPrompts.device_changed.connect(func(_device: int) -> void: update.call())
|
||||
return label
|
||||
|
||||
|
||||
## Zeigt einen zentrierten Bildschirm-Prompt (baut die UI beim ersten
|
||||
## Aufruf lazy auf).
|
||||
func show_prompt(text: String) -> void:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -86,7 +86,11 @@ func _physics_process(delta: float) -> void:
|
|||
if not _is_in_course():
|
||||
return
|
||||
_check_passing_touch()
|
||||
if _player.velocity.y < -6.0:
|
||||
if _player.velocity.y > -7.0:
|
||||
return
|
||||
var is_in_corridor: bool = _player.global_position.z > 0.8
|
||||
var is_deep_fall: bool = _player.global_position.y < _last_floor_y - 3.0
|
||||
if is_in_corridor or is_deep_fall:
|
||||
attempt_catch()
|
||||
|
||||
|
||||
|
|
@ -110,7 +114,7 @@ func attempt_catch() -> void:
|
|||
func _run_catch_qte() -> void:
|
||||
var frozen := _player.global_position
|
||||
_player.set_control_locked(true)
|
||||
_label.text = "SEIL GREIFEN! — Leertaste / A-Taste"
|
||||
_label.text = "SEIL GREIFEN! — %s" % InputPrompts.prompt("grab_rope")
|
||||
_label.visible = true
|
||||
await get_tree().physics_frame
|
||||
var window := rope_catch_window
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue