V.0.6.1
This commit is contained in:
parent
6f92fc0ae0
commit
bc410156ee
41 changed files with 1058 additions and 743 deletions
|
|
@ -63,13 +63,17 @@ func _physics_process(delta: float) -> void:
|
|||
_was_charging = is_charging
|
||||
|
||||
|
||||
## Klammert den Spieler an die Kugel, wenn er frei in die Greif-Zone kommt.
|
||||
## 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"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
if to_local(player.global_position).distance_to(_ball.position) > 3.0:
|
||||
return
|
||||
_is_holding = true
|
||||
_charge = 0.0
|
||||
_was_charging = false
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ func _physics_process(delta: float) -> void:
|
|||
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))
|
||||
player.external_push = global_transform.basis.z * roll_speed * float(roll_dir)
|
||||
_was_on_log = true
|
||||
elif _was_on_log:
|
||||
player.external_push = Vector3.ZERO
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ func _physics_process(delta: float) -> void:
|
|||
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)
|
||||
player.external_push = global_transform.basis.x * drift
|
||||
_was_on_pillar = true
|
||||
elif _was_on_pillar:
|
||||
player.external_push = Vector3.ZERO
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ func _physics_process(delta: float) -> void:
|
|||
var drift := log_spin_speed * log_radius
|
||||
if nerve != null:
|
||||
drift *= nerve.drift_factor()
|
||||
player.external_push = Vector3(drift, 0.0, 0.0)
|
||||
player.external_push = global_transform.basis.x * drift
|
||||
_was_on_log = true
|
||||
elif _was_on_log:
|
||||
player.external_push = Vector3.ZERO
|
||||
|
|
|
|||
|
|
@ -1,109 +1,205 @@
|
|||
extends GauntletObstacle
|
||||
## Spinning Wheel (CR-002, ascent_1): großes, konstant drehendes Rad.
|
||||
## Spinning Wheel als geschlossene Trommel (CR-003 §3b).
|
||||
##
|
||||
## 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.
|
||||
## 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).
|
||||
|
||||
signal wheel_entered
|
||||
signal wheel_gap_cleared
|
||||
signal wheel_exited
|
||||
|
||||
@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)
|
||||
@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
|
||||
|
||||
var _pivot: Node3D
|
||||
var _dummy1: MeshInstance3D
|
||||
var _dummy2: MeshInstance3D
|
||||
var _is_riding := false
|
||||
var _ride_angle := 0.0
|
||||
var _is_in_entry_zone := false
|
||||
var _player_angle := 0.0
|
||||
var _hop_timer := 0.0
|
||||
var _has_cleared_pass := false
|
||||
var _time := 0.0
|
||||
|
||||
|
||||
## Baut Rad-Visual (Speichen + Kranz-Segmente), Dummy-Kadetten,
|
||||
## Einstiegs-Zone und Ausstiegs-Plattform.
|
||||
## Baut Haut-Segmente (mit Lücke), Nabe, 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
|
||||
var gap_half := wheel_gap_arc / 2.0
|
||||
var segment_count := 14
|
||||
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
|
||||
_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"
|
||||
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))
|
||||
|
||||
|
||||
## Dreht Rad und Dummy-Kadetten; während der Fahrt wird der Spieler auf
|
||||
## der Kreisbahn geführt und der Ausstieg abgefragt.
|
||||
## 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.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_pivot.rotate_x(-wheel_speed * delta)
|
||||
_time += delta
|
||||
_pivot.rotate_z(wheel_speed * float(wheel_dir) * 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 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)
|
||||
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")
|
||||
if _is_riding:
|
||||
_process_ride(player, delta, inner)
|
||||
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)
|
||||
_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:
|
||||
_finish_ride(false)
|
||||
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
|
||||
|
||||
|
||||
## 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:
|
||||
## Erfolgreicher Ausstieg durch die Lücke auf die Plattform dahinter.
|
||||
func _finish_ride(player: CharacterBody3D) -> 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()
|
||||
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()
|
||||
mark_cleared()
|
||||
|
||||
|
||||
## 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)
|
||||
## 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()
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade im Rad mitfährt (für Tests).
|
||||
## 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).
|
||||
func is_riding() -> bool:
|
||||
return _is_riding
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ func _physics_process(_delta: float) -> void:
|
|||
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)
|
||||
player.external_push = global_transform.basis.z * slide_back_push
|
||||
else:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_ramp = true
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue