Die Lippen an den Oeffnungen sind raus. Gemessen: Sie waren redundant geworden — ohne sie bleibt der Einstieg unterhalb der Luecke dicht, weil die Huelle seit CR 31a selbst blockt. Solange die Huelle reine Optik war, waren die Lippen die einzige Sperre. Dabei aufgefallen: CR 31a hatte das Rad unpassierbar gemacht. Bei wheel_gap_arc = 1.0 ist die Luecke am Einstieg nur 1,74 m hoch, die Spielerkapsel misst 1,80 m — sie passte gar nicht mehr durch, unabhaengig vom Timing, und die Unterkante lag mit 1,13 m ueber dem Sprungscheitel von 1,03 m. Vorher fiel das nicht auf, weil man schlicht durch die kollisionslose Huelle lief; die Luecke war nie ein echter Durchgang, sondern Optik plus Timing-Anzeige. Mit der festen Huelle wurde sie zur einzigen Tuer, und die war zu klein. Fix: wheel_gap_arc 1,0 auf 1,4, gemessen ueber fuenf Kandidaten als kleinster Wert mit echtem Spielraum — Oeffnung 2,38 m, Unterkante 0,81 m. gap_arc stand nicht auf der Nicht-anfassen-Liste; entry_window, exit_window und carry_force sind unveraendert, und weil das Fenster (0,6) enger bleibt als die halbe Luecke (0,7), gibt weiterhin das Fenster das Timing vor. Die Sperrwand war an LIP_HEIGHT ausgerichtet und begann erst bei 0,90 m. Mit der breiteren Luecke blieb darunter ein 9-cm-Schlitz offen — fuer eine 1,80-m-Kapsel harmlos, aber falsch. Sie deckt jetzt die volle Oeffnungshoehe ab; LIP_HEIGHT ist ersatzlos entfallen. Verifiziert mit einer Abschluss-Sonde (9/9) und einem Boot-Check ueber neun Szenen plus Terrassen-Konfiguration; zwei Renderings geprueft, Sonden vor dem Commit geloescht. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
221 lines
9.2 KiB
GDScript
221 lines
9.2 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), durch die Lücke
|
|
## springen — sie steht auf Brusthöhe, man muss sie treffen —, 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: Speichen auf beiden Stirnseiten, die mit _pivot
|
|
## drehen — von der Seite sieht man jetzt ein Mühlrad.
|
|
##
|
|
## **Lippen entfernt (Nachtrag zu CR 31, Autoren-Wunsch):** Die beiden
|
|
## festen Blöcke an den Öffnungen sind weg. Sie waren nur nötig, solange
|
|
## die Hülle keine Kollision hatte — jetzt schließt die Hülle die
|
|
## Öffnungen unterhalb der Lücke von allein. Dafür musste
|
|
## **wheel_gap_arc von 1,0 auf 1,4** wachsen: Mit der festen Hülle ist
|
|
## die Lücke der einzige Weg hinein, und bei 1,0 war sie nur 1,74 m hoch
|
|
## — schmaler als die 1,80 m hohe Spielerkapsel, das Rad war schlicht
|
|
## nicht mehr passierbar. Bei 1,4 misst die Öffnung 2,38 m, ihre
|
|
## Unterkante liegt bei 0,81 m unter dem Sprungscheitel von 1,03 m.
|
|
## wheel_entry_window (0,6) bleibt strenger als die halbe Lücke (0,7)
|
|
## und gibt damit weiterhin das Timing vor.
|
|
|
|
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.4
|
|
@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 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
|
|
|
|
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)
|
|
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)
|
|
|
|
|
|
## Baut eine unsichtbare Sperrwand vor einer Trommelseite; ihre Shape
|
|
## wird freigegeben, solange die Lücke dort steht. Sie deckt die volle
|
|
## Höhe der Öffnung ab — früher setzte sie erst über der Lippe an, was
|
|
## nach deren Entfernung einen schmalen Schlitz unter der Wand offen
|
|
## ließ.
|
|
func _build_wall(local_x: float, center_y: float) -> CollisionShape3D:
|
|
var wall := StaticBody3D.new()
|
|
wall.position = Vector3(local_x, center_y, 0)
|
|
var shape := CollisionShape3D.new()
|
|
var box := BoxShape3D.new()
|
|
box.size = Vector3(0.3, wheel_diameter, 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
|