CR 7: Gauntlet-Rad als stehendes Mühlrad mit einer Lücke
- spinning_wheel.gd komplett neu: aufrechte Trommel über der Weglücke, Drehachse waagerecht quer zur Laufrichtung, 14 Hüllen-Segmente mit genau EINER Lücke, zwei Paddel als Timing-Referenz - Ein-/Ausstieg: feste Hüllen-Lippe (drüberspringen) + unsichtbare Sperrwand, die nur freigibt, solange die Lücke im jeweiligen Fenster steht (wheel_entry_window/wheel_exit_window — dieselbe Lücke bedient beide Seiten); innen trägt die Drehung Richtung Ausstieg - Falsches Timing: zieht die Lücke unten durch, während der Läufer am Boden steht, fällt er in die Grube (report_fall → Respawn) - Tuning in Grad/Sekunde: wheel_speed_deg (Standard 40) ersetzt wheel_speed in terrace_config.gd, terrace_1.tres und BEHAVIOR_TUNABLES - Buchführung: CR 7 nach CHANGEREQUESTS_DONE Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
parent
3dc81237b2
commit
f18e6d3a4d
6 changed files with 280 additions and 121 deletions
|
|
@ -42,7 +42,7 @@ const TERRACE_CONFIG_PATHS: Array[String] = [
|
|||
"res://data/gauntlet/terrace_5.tres",
|
||||
]
|
||||
const BEHAVIOR_TUNABLES: Array[String] = [
|
||||
"log_spin_speed", "wheel_speed", "wheel_dir", "wheel_entry_window",
|
||||
"log_spin_speed", "wheel_speed_deg", "wheel_dir", "wheel_entry_window",
|
||||
"gap_jump_window", "wheel_exit_window", "wheel_carry_force",
|
||||
"buoy_swing_period", "launch_window", "momentum_charge_time",
|
||||
"hangel_rhythm_window", "shake_amplitude", "shake_frequency",
|
||||
|
|
|
|||
|
|
@ -1,129 +1,148 @@
|
|||
extends GauntletObstacle
|
||||
## Spinning Wheel als flache Dreh-Scheibe (CR Gameplay-Fixes: das Rad
|
||||
## liegt flach auf dem Boden, Interaktion rein über Hitbox — kein
|
||||
## Tastendruck zum Starten).
|
||||
## Spinning Wheel als STEHENDES Mühlrad (CR 7 — ersetzt die flache
|
||||
## Dreh-Scheibe; Soll-Zustand laut CR-003-Rad-Spezifikation).
|
||||
##
|
||||
## 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.
|
||||
## Aufrechte Trommel über der Weglücke: Die Drehachse liegt waagerecht
|
||||
## und quer zur Laufrichtung (lokale z-Achse), die geschlossene äußere
|
||||
## Hülle trägt genau EINE Lücke (wheel_gap_arc). Ablauf: Warten, bis
|
||||
## die Lücke an der Einstiegsseite vorbeikommt (unsichtbare
|
||||
## Einstiegswand öffnet nur im wheel_entry_window), über die
|
||||
## Hüllen-Lippe hindurchspringen, im Inneren trägt die Drehung den
|
||||
## Läufer Richtung Ausstieg (wheel_carry_force) — und wenn DIESELBE
|
||||
## Lücke auf der gegenüberliegenden Seite ankommt (wheel_exit_window),
|
||||
## springt er durch dasselbe Loch wieder hinaus. Falsches Timing im
|
||||
## Inneren: Zieht die Lücke unten durch, fällt der Läufer in die
|
||||
## Grube (report_fall → Respawn), es sei denn, er ist im Sprung.
|
||||
## Drehgeschwindigkeit tunebar in GRAD/SEKUNDE (wheel_speed_deg, über
|
||||
## data/gauntlet/terrace_1.tres); wheel_dir 1 = Uhrzeigersinn aus
|
||||
## Sicht des zulaufenden Spielers (die Trommel-Unterseite läuft mit in
|
||||
## Laufrichtung und trägt zum Ausstieg). Zwei Paddel drehen als
|
||||
## sichtbare Timing-Referenz mit.
|
||||
|
||||
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_speed_deg := 40.0
|
||||
@export var wheel_dir := 1
|
||||
@export var wheel_gap_arc := 1.0
|
||||
@export var wheel_carry_force := 1.0
|
||||
@export var hub_radius := 0.7
|
||||
@export var wheel_entry_window := 0.6
|
||||
@export var wheel_exit_window := 0.5
|
||||
@export var wheel_carry_force := 0.35
|
||||
@export var drum_width := 2.2
|
||||
|
||||
const ENTRY_ANGLE := PI
|
||||
const EXIT_ANGLE := 0.0
|
||||
const BOTTOM_ANGLE := -PI / 2.0
|
||||
const LIP_HEIGHT := 0.9
|
||||
|
||||
var _pivot: Node3D
|
||||
var _was_on_disc := false
|
||||
var _entry_wall_shape: CollisionShape3D
|
||||
var _exit_wall_shape: CollisionShape3D
|
||||
var _gap_angle := ENTRY_ANGLE
|
||||
var _was_inside := false
|
||||
var _has_entered := false
|
||||
var _has_exited := false
|
||||
var _was_gap_near := false
|
||||
var _time := 0.0
|
||||
|
||||
|
||||
## Baut Scheiben-Segmente (mit Lücke), Nabe, Kollisions-Scheibe,
|
||||
## Dummy-Kadetten und die Ausstiegs-Zone.
|
||||
## Baut die Trommel: rotierende Hüllen-Segmente mit einer Lücke,
|
||||
## Paddel als Timing-Referenz, inneren Stützboden, Einstiegs-/
|
||||
## Ausstiegswände samt fester Lippen 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)
|
||||
var center := Vector3(0, radius, 0)
|
||||
_pivot = Node3D.new()
|
||||
_pivot.position = center
|
||||
add_child(_pivot)
|
||||
var gap_half := wheel_gap_arc / 2.0
|
||||
var segment_count := 12
|
||||
var segment_count := 14
|
||||
var arc := TAU - wheel_gap_arc
|
||||
var segment_length := arc / float(segment_count) * radius
|
||||
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.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
|
||||
var angle := ENTRY_ANGLE + wheel_gap_arc / 2.0 + arc * (float(i) + 0.5) / float(segment_count)
|
||||
var segment := build_box_mesh(Vector3(segment_length * 1.05, 0.25, drum_width), Vector3(cos(angle) * radius, sin(angle) * radius, 0), Color(0.5, 0.4, 0.3))
|
||||
segment.rotation.z = angle + PI / 2.0
|
||||
_pivot.add_child(segment)
|
||||
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))
|
||||
var paddle1 := build_box_mesh(Vector3(0.2, radius * 0.8, drum_width * 0.9), Vector3(cos(ENTRY_ANGLE + PI * 0.5) * radius * 0.55, sin(ENTRY_ANGLE + PI * 0.5) * radius * 0.55, 0), Color(0.35, 0.35, 0.5))
|
||||
paddle1.rotation.z = ENTRY_ANGLE + PI * 0.5 + PI / 2.0
|
||||
_pivot.add_child(paddle1)
|
||||
var paddle2 := build_box_mesh(Vector3(0.2, radius * 0.8, drum_width * 0.9), Vector3(cos(ENTRY_ANGLE + PI * 1.4) * radius * 0.55, sin(ENTRY_ANGLE + PI * 1.4) * radius * 0.55, 0), Color(0.3, 0.4, 0.45))
|
||||
paddle2.rotation.z = ENTRY_ANGLE + PI * 1.4 + PI / 2.0
|
||||
_pivot.add_child(paddle2)
|
||||
var floor_body := StaticBody3D.new()
|
||||
floor_body.position = Vector3(0, -0.15, 0)
|
||||
var floor_shape := CollisionShape3D.new()
|
||||
var floor_box := BoxShape3D.new()
|
||||
floor_box.size = Vector3(wheel_diameter - 0.7, 0.3, drum_width)
|
||||
floor_shape.shape = floor_box
|
||||
floor_body.add_child(floor_shape)
|
||||
add_child(floor_body)
|
||||
_entry_wall_shape = _build_wall(-radius, center.y)
|
||||
_exit_wall_shape = _build_wall(radius, center.y)
|
||||
build_box(self, Vector3(0.3, LIP_HEIGHT, drum_width), Vector3(-radius, LIP_HEIGHT / 2.0, 0), Color(0.45, 0.36, 0.28))
|
||||
build_box(self, Vector3(0.3, LIP_HEIGHT, drum_width), Vector3(radius, LIP_HEIGHT / 2.0, 0), Color(0.45, 0.36, 0.28))
|
||||
var exit_zone := build_area(self, Vector3(1.2, 2.6, drum_width + 0.4), Vector3(radius + 0.9, 1.2, 0))
|
||||
exit_zone.body_entered.connect(_on_exit_zone)
|
||||
|
||||
|
||||
## Dreht die Scheibe und wendet Mitreiß-Kraft, Lücken-Logik und
|
||||
## Betreten-Erkennung auf den Läufer an.
|
||||
## Baut eine unsichtbare Sperrwand über der Lippe einer Trommelseite;
|
||||
## ihre Shape wird freigegeben, solange die Lücke dort steht.
|
||||
func _build_wall(local_x: float, center_y: float) -> CollisionShape3D:
|
||||
var wall := StaticBody3D.new()
|
||||
wall.position = Vector3(local_x, center_y + LIP_HEIGHT / 2.0, 0)
|
||||
var shape := CollisionShape3D.new()
|
||||
var box := BoxShape3D.new()
|
||||
box.size = Vector3(0.3, wheel_diameter - LIP_HEIGHT, drum_width)
|
||||
shape.shape = box
|
||||
wall.add_child(shape)
|
||||
add_child(wall)
|
||||
return shape
|
||||
|
||||
|
||||
## Dreht die Trommel, öffnet die Wände im Lücken-Fenster, trägt den
|
||||
## Läufer im Inneren mit und lässt ihn fallen, wenn die Lücke unten
|
||||
## durchzieht, während er am Boden steht.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_time += delta
|
||||
_pivot.rotate_y(wheel_speed * float(wheel_dir) * delta)
|
||||
var omega := deg_to_rad(wheel_speed_deg) * float(wheel_dir)
|
||||
_gap_angle = wrapf(_gap_angle + omega * delta, -PI, PI)
|
||||
_pivot.rotation.z += omega * delta
|
||||
_entry_wall_shape.set_deferred("disabled", _is_gap_at(ENTRY_ANGLE, wheel_entry_window))
|
||||
_exit_wall_shape.set_deferred("disabled", _is_gap_at(EXIT_ANGLE, wheel_exit_window))
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
var local := to_local(player.global_position)
|
||||
var radial := Vector2(local.x, local.z)
|
||||
var radius := wheel_diameter / 2.0
|
||||
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:
|
||||
var is_inside: bool = absf(local.x) < radius - 0.35 and absf(local.z) < drum_width / 2.0 + 0.4 and local.y > -0.3 and local.y < wheel_diameter
|
||||
if not is_inside:
|
||||
if _was_inside:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_disc = false
|
||||
_was_inside = 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)
|
||||
_was_inside = true
|
||||
var push := Vector3(deg_to_rad(wheel_speed_deg) * float(wheel_dir) * radius * wheel_carry_force, 0, 0)
|
||||
if nerve != null:
|
||||
push *= nerve.drift_factor()
|
||||
player.external_push = global_transform.basis * push
|
||||
_process_gap(player, local, radial)
|
||||
if _is_gap_at(BOTTOM_ANGLE, wheel_gap_arc / 2.0 * 0.8) and player.is_on_floor():
|
||||
player.external_push = Vector3.ZERO
|
||||
player.global_position = to_global(Vector3(local.x, -1.2, local.z))
|
||||
player.velocity = Vector3(0, -6.5, 0)
|
||||
_was_inside = false
|
||||
report_fall()
|
||||
|
||||
|
||||
## 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
|
||||
## Prüft, ob die Lücke gerade im Fenster um den Ziel-Winkel steht.
|
||||
func _is_gap_at(target_angle: float, window: float) -> bool:
|
||||
return absf(wrapf(_gap_angle - target_angle, -PI, PI)) < window
|
||||
|
||||
|
||||
## Ausstiegs-Zone hinter der Scheibe erreicht: Übergang geschafft.
|
||||
## Ausstiegs-Zone hinter der Trommel erreicht: Hindernis geschafft.
|
||||
func _on_exit_zone(body: Node3D) -> void:
|
||||
if not body.is_in_group("player"):
|
||||
return
|
||||
|
|
@ -133,6 +152,6 @@ func _on_exit_zone(body: Node3D) -> void:
|
|||
mark_cleared()
|
||||
|
||||
|
||||
## Meldet, ob der Läufer gerade auf der Scheibe steht (für Tests).
|
||||
## Meldet, ob der Läufer gerade in der Trommel steht (für Tests).
|
||||
func is_riding() -> bool:
|
||||
return _was_on_disc
|
||||
return _was_inside
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ extends Resource
|
|||
@export var pillar_count := 4
|
||||
|
||||
@export var wheel_diameter := 4.0
|
||||
@export var wheel_speed := 0.8
|
||||
@export var wheel_speed_deg := 40.0
|
||||
@export var wheel_dir := 1
|
||||
@export var wheel_gap_arc := 1.0
|
||||
@export var wheel_entry_window := 0.6
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue