windgeschworen/scripts/gameplay/obstacles/spinning_wheel.gd
danny 7b8a1a3409 CR 31: Gauntlet-Rad — feste Huelle, Tuerrahmen, Speichen
Hauptfix: Die 14 Huellen-Segmente wurden mit build_box_mesh() gebaut, das
laut obstacle_base bewusst kein Kollisions-Shape erzeugt — die Aussenhuelle
war reine Optik, man lief ueberall hindurch statt nur durch die Luecke. Jedes
Segment ist jetzt ein AnimatableBody3D mit eigenem BoxShape und Kind von
_pivot, dreht also mit. sync_to_physics bleibt aus: die Segmente sollen
blocken, das Mitnehmen macht weiterhin allein wheel_carry_force, sonst haette
die Huelle den Laeufer zusaetzlich geschoben und die CR-7-Balance
verfaelscht. Die Luecke bleibt frei, weil die Segmentschleife sie ohnehin
aussparte.

Die beiden festen Lippen bleiben, wo sie sind — sie sind die Kante, ueber die
man springt — bekommen aber einen feststehenden Rahmen aus zwei Pfosten und
Sturz, rein dekorativ und nicht Kind von _pivot. Im Rendering liest sich die
Lippe jetzt als Schwelle einer Toroeffnung statt als loser Block. Die Paddel
tragen die Holztoene der Huelle. Auf beiden Stirnseiten je drei Balken durch
die Mitte plus Nabe, ohne Kollision — von der Seite zeigt das Rad jetzt eine
erkennbare Muehlrad-Silhouette.

Zwei Fehlschlaege waren meine Pruefer, nicht der Code: AnimatableBody3D erbt
von StaticBody3D, mein Rahmen-Test schlug deshalb auf die eigenen Segmente
an. Und ein Testkoerper, der radial gegen die Huelle drueckt, rutscht an der
tangentialen Flaeche entlang bis in die Luecke — korrektes Verhalten, aber
als Loch fehlgedeutet. Der Nachweis laeuft darum ueber Strahlen, die nicht
rutschen.

Rotationslogik, Ein-/Ausstiegsfenster, Mitnahme-Physik und Sturz-Bedingung
sind zeichengleich unveraendert; die CR-7-Sonden bleiben gueltig.

Verifiziert mit dev_cr31_probe (20/20) und dev_cr31_solid (4/4: 149 Strahlen
rundum blocken ausnahmslos, alle neun in der Luecke gehen durch, die Luecke
wandert mit), einem Boot-Check ueber zehn Szenen inklusive aller fuenf
Terrassen und drei gerenderten Ansichten; Sonden vor dem Commit geloescht.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 06:19:26 +02:00

231 lines
9.6 KiB
GDScript

extends GauntletObstacle
## Spinning Wheel als STEHENDES Mühlrad (CR 7 — ersetzt die flache
## Dreh-Scheibe; Soll-Zustand laut CR-003-Rad-Spezifikation).
##
## 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.
##
## **Hülle ist fest (CR 31):** Die Segmente sind AnimatableBody3D — sie
## drehen mit _pivot und blocken echt. Vorher waren sie reine Meshes
## (build_box_mesh erzeugt laut obstacle_base bewusst keine Kollision),
## man konnte also überall durchlaufen statt nur durch die Lücke. Die
## Lücke selbst bleibt frei, weil die Segmentschleife sie ohnehin
## aussparte. sync_to_physics bleibt aus: Die Segmente sollen blocken,
## das Mitnehmen macht weiterhin allein wheel_carry_force.
##
## Rein dekorativ dazu: ein feststehender Rahmen um beide Öffnungen
## (damit die Lippen als Teil der Öffnung lesbar sind statt als lose
## Blöcke) und Speichen auf beiden Stirnseiten, die mit _pivot drehen —
## von der Seite sieht man jetzt ein Mühlrad.
signal wheel_entered
signal wheel_exited
@export var wheel_diameter := 4.0
@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
@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
const SEGMENT_COUNT := 14
const SEGMENT_THICKNESS := 0.25
const WOOD_SHELL := Color(0.5, 0.4, 0.3)
const WOOD_FRAME := Color(0.42, 0.33, 0.24)
const WOOD_SPOKE := Color(0.46, 0.36, 0.27)
const SPOKE_BARS := 3
const FRAME_POST_WIDTH := 0.22
var _pivot: Node3D
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
## 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 center := Vector3(0, radius, 0)
_pivot = Node3D.new()
_pivot.position = center
add_child(_pivot)
var arc := TAU - wheel_gap_arc
var segment_length := arc / float(SEGMENT_COUNT) * radius
for i in SEGMENT_COUNT:
var angle := ENTRY_ANGLE + wheel_gap_arc / 2.0 + arc * (float(i) + 0.5) / float(SEGMENT_COUNT)
_build_shell_segment(angle, segment_length, radius)
_build_spokes(radius)
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), WOOD_SPOKE)
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), WOOD_SHELL)
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), WOOD_FRAME)
build_box(self, Vector3(0.3, LIP_HEIGHT, drum_width), Vector3(radius, LIP_HEIGHT / 2.0, 0), WOOD_FRAME)
_build_opening_frame(-radius)
_build_opening_frame(radius)
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)
## Ein Hüllen-Segment mit echter Kollision, das mit _pivot dreht
## (CR 31a). AnimatableBody3D statt StaticBody3D, weil der Körper per
## Code bewegt wird; sync_to_physics bleibt aus, damit er nur blockt und
## die Mitnahme allein bei wheel_carry_force liegt.
func _build_shell_segment(angle: float, segment_length: float, radius: float) -> void:
var body := AnimatableBody3D.new()
body.sync_to_physics = false
body.position = Vector3(cos(angle) * radius, sin(angle) * radius, 0)
body.rotation.z = angle + PI / 2.0
var size := Vector3(segment_length * 1.05, SEGMENT_THICKNESS, drum_width)
var shape := CollisionShape3D.new()
var box := BoxShape3D.new()
box.size = size
shape.shape = box
body.add_child(shape)
body.add_child(build_box_mesh(size, Vector3.ZERO, WOOD_SHELL))
_pivot.add_child(body)
## Speichen und Nabe auf beiden Stirnseiten der Trommel (CR 31d) — rein
## dekorativ, dreht mit _pivot. Jeder Balken läuft durch die Mitte und
## bildet damit zwei gegenüberliegende Speichen.
func _build_spokes(radius: float) -> void:
for side in [-1.0, 1.0]:
var z: float = side * (drum_width / 2.0 + 0.04)
for i in SPOKE_BARS:
var bar := build_box_mesh(
Vector3(0.16, radius * 2.0 - SEGMENT_THICKNESS, 0.08),
Vector3(0, 0, z), WOOD_SPOKE)
bar.rotation.z = PI * float(i) / float(SPOKE_BARS)
_pivot.add_child(bar)
var hub := build_cylinder_mesh(radius * 0.16, 0.14, Vector3(0, 0, z), WOOD_FRAME)
hub.rotation.x = PI / 2.0
_pivot.add_child(hub)
## Feststehender Rahmen um eine Ein-/Ausstiegsöffnung (CR 31b): zwei
## Pfosten seitlich der Durchgangsbreite und ein Sturz darüber. Rein
## dekorativ und NICHT Kind von _pivot — er gehört zum Gerüst, nicht zur
## Trommel, und macht die Lippe als Teil der Öffnung lesbar.
func _build_opening_frame(local_x: float) -> void:
var height := wheel_diameter
for side in [-1.0, 1.0]:
var post := build_box_mesh(
Vector3(FRAME_POST_WIDTH, height, FRAME_POST_WIDTH),
Vector3(local_x, height / 2.0, float(side) * (drum_width / 2.0 + FRAME_POST_WIDTH / 2.0)),
WOOD_FRAME)
add_child(post)
var lintel := build_box_mesh(
Vector3(FRAME_POST_WIDTH, FRAME_POST_WIDTH, drum_width + FRAME_POST_WIDTH * 2.0),
Vector3(local_x, height + FRAME_POST_WIDTH / 2.0, 0), WOOD_FRAME)
add_child(lintel)
## 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:
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 radius := wheel_diameter / 2.0
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_inside = false
return
if not is_player_free(player):
return
if not _has_entered:
_has_entered = true
wheel_entered.emit()
_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
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 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 Trommel erreicht: Hindernis 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()
## Meldet, ob der Läufer gerade in der Trommel steht (für Tests).
func is_riding() -> bool:
return _was_inside