extends CharacterBody3D ## Greybox-Spielersteuerung (Phase 0 + Movement-Upgrade Phase 1b). ## ## Bewegt die Spieler-Kapsel relativ zur Kamera (WASD + linker Stick) mit ## Sprint und Sprung, dazu die weit rausgezoomte Third-Person-Kamera im ## WoW-Stil über SpringArm3D (Orbit: Maus + rechter Stick, Zoom: Mausrad + ## Schultertasten). Phase 1b ergänzt eine Zustandsmaschine: Slide (kurzer, ## geschwindigkeitsabhängiger Rutsch-Impuls mit reduzierter Kapselhöhe über ## die slide-Action) und automatisches Hochziehen an Kanten unterhalb einer ## Maximalhöhe, wenn der Spieler im Sprung gegen eine Wand stößt (einfache ## Kantenerkennung per Raycast). Die Kapsel-Shape wird beim Start ## dupliziert, damit Größenänderungen keine NPC-Kapseln mit geteilter ## Ressource betreffen. Mausbewegung ist in Godot nicht auf Actions mappbar ## und wird direkt als InputEventMouseMotion gelesen, der rechte Stick ## direkt über die Joypad-Achsen (Deadzone 0.2). enum MovementState { NORMAL, SLIDING, CLIMBING } const WALK_SPEED := 4.0 const SPRINT_SPEED := 7.5 const STOP_SPEED := 16.0 const JUMP_SPEED := 4.5 const MESH_TURN_SPEED := 10.0 const MOUSE_SENSITIVITY := 0.003 const STICK_LOOK_SPEED := 2.5 const STICK_DEADZONE := 0.2 const PITCH_MIN := -1.2 const PITCH_MAX := 0.5 const ZOOM_MIN := 2.0 const ZOOM_MAX := 14.0 const ZOOM_STEP := 0.8 const ZOOM_BUTTON_SPEED := 8.0 const ZOOM_SMOOTHING := 10.0 const SLIDE_MIN_ENTRY_SPEED := 2.0 const SLIDE_MIN_SPEED := 6.0 const SLIDE_SPEED_BOOST := 1.35 const SLIDE_DURATION := 0.7 const SLIDE_CAPSULE_HEIGHT := 1.0 const SLIDE_MESH_SQUASH := 0.55 const STAND_CAPSULE_HEIGHT := 1.8 const CLIMB_MIN_LEDGE_HEIGHT := 0.4 const CLIMB_MAX_LEDGE_HEIGHT := 2.2 const CLIMB_PROBE_MARGIN := 0.3 const CLIMB_FORWARD_PROBE := 0.5 const CLIMB_LANDING_INSET := 0.35 const CLIMB_HEADROOM := 1.7 const CLIMB_DURATION := 0.4 const CLIMB_VERTICAL_PHASE := 0.6 const PAN_START_YAW := 2.4 const PAN_START_PITCH := -0.55 const PAN_START_ZOOM := 14.0 const PAN_END_PITCH := -0.35 const PAN_DURATION := 3.0 var _state := MovementState.NORMAL var _is_dialogue_locked := false var _is_panning := false var external_push := Vector3.ZERO var _target_zoom := 9.0 var _gravity: float = ProjectSettings.get_setting("physics/3d/default_gravity") var _slide_direction := Vector3.ZERO var _slide_start_speed := 0.0 var _slide_time := 0.0 var _climb_start := Vector3.ZERO var _climb_corner := Vector3.ZERO var _climb_target := Vector3.ZERO var _climb_time := 0.0 @onready var _camera_pivot: Node3D = $CameraPivot @onready var _spring_arm: SpringArm3D = $CameraPivot/SpringArm3D @onready var _mesh: MeshInstance3D = $MeshInstance3D @onready var _collision_shape: CollisionShape3D = $CollisionShape3D @onready var _capsule: CapsuleShape3D = _collision_shape.shape.duplicate() ## Fängt den Mauszeiger ein, übernimmt die SpringArm-Länge als Zoom-Ziel, ## gibt dem Spieler eine eigene Kapsel-Shape-Instanz und koppelt die ## Bewegungssperre an die Dialog-Signale. func _ready() -> void: Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) _target_zoom = _spring_arm.spring_length _collision_shape.shape = _capsule DialogueSystem.dialogue_started.connect(_on_dialogue_started) DialogueSystem.dialogue_finished.connect(_on_dialogue_finished) ## Verarbeitet Maus-Look, Mausrad-Zoom sowie das Freigeben des Cursors über ## cancel und das Wieder-Einfangen per Mausklick. func _unhandled_input(event: InputEvent) -> void: if event is InputEventMouseMotion and Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED: if not _is_dialogue_locked: _rotate_camera(-event.relative.x * MOUSE_SENSITIVITY, -event.relative.y * MOUSE_SENSITIVITY) elif event is InputEventMouseButton and event.pressed: if event.is_action("camera_zoom_in"): _target_zoom = clampf(_target_zoom - ZOOM_STEP, ZOOM_MIN, ZOOM_MAX) elif event.is_action("camera_zoom_out"): _target_zoom = clampf(_target_zoom + ZOOM_STEP, ZOOM_MIN, ZOOM_MAX) elif Input.get_mouse_mode() != Input.MOUSE_MODE_CAPTURED and not _is_dialogue_locked: Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) elif event.is_action_pressed("cancel"): if not _is_dialogue_locked: Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) ## Treibt Kamera und den aktiven Bewegungszustand pro Physik-Tick an; ## während eines Dialogs sind Bewegung und Kamera-Look gesperrt. func _physics_process(delta: float) -> void: if _is_dialogue_locked: _process_dialogue_lock(delta) return _apply_stick_look(delta) _apply_button_zoom(delta) _apply_zoom_smoothing(delta) match _state: MovementState.NORMAL: _process_normal(delta) MovementState.SLIDING: _process_slide(delta) MovementState.CLIMBING: _process_climb(delta) ## Hält den Spieler während eines Dialogs an: Schwerkraft und Auslaufen ## bleiben aktiv, Eingaben für Bewegung, Sprung, Slide und Look nicht. ## Während eines Kamera-Schwenks steuert der Tween die SpringArm-Länge, ## nicht die Zoom-Glättung. func _process_dialogue_lock(delta: float) -> void: if not is_on_floor(): velocity.y -= _gravity * delta velocity.x = move_toward(velocity.x, 0.0, STOP_SPEED * delta) velocity.z = move_toward(velocity.z, 0.0, STOP_SPEED * delta) move_and_slide() if not _is_panning: _apply_zoom_smoothing(delta) ## Sperrt oder entsperrt die Steuerung von außen (Set-Pieces und ## QTE-Encounter nutzen dieselbe Sperre wie Dialoge). func set_control_locked(is_locked: bool) -> void: if is_locked and _state == MovementState.SLIDING: _end_slide() _is_dialogue_locked = is_locked ## Gibt zurück, ob die Steuerung gerade gesperrt ist (Dialog, Kamera- ## Schwenk, QTE). Das Wind-/Balance-System des Viadukts pausiert dann. func is_control_locked() -> bool: return _is_dialogue_locked ## Spielt einen kurzen cineastischen Kamera-Schwenk für Set-Pieces ## (SPEC Abschnitt 2): Die Kamera startet weit draußen und seitlich und ## fährt weich in die Standard-Third-Person-Ansicht zurück; die Steuerung ## ist für die Dauer gesperrt. func play_camera_pan(duration := PAN_DURATION) -> void: _is_dialogue_locked = true _is_panning = true _camera_pivot.rotation.y = PAN_START_YAW _spring_arm.rotation.x = PAN_START_PITCH _spring_arm.spring_length = PAN_START_ZOOM _target_zoom = 9.0 var tween := create_tween().set_parallel(true).set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN_OUT) tween.tween_property(_camera_pivot, "rotation:y", 0.0, duration) tween.tween_property(_spring_arm, "rotation:x", PAN_END_PITCH, duration) tween.tween_property(_spring_arm, "spring_length", _target_zoom, duration) await tween.finished _is_panning = false _is_dialogue_locked = false ## Sperrt Bewegung und Look bei Dialogbeginn und gibt die Maus frei, ## damit die Antwortauswahl auch per Klick bedienbar ist; ein laufender ## Slide endet sauber, damit die Kapsel nicht geduckt stehen bleibt. func _on_dialogue_started(_dialogue_id: String) -> void: if _state == MovementState.SLIDING: _end_slide() _is_dialogue_locked = true Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) ## Gibt Bewegung und Look nach Dialogende wieder frei und fängt die Maus ## wieder ein. func _on_dialogue_finished(_dialogue_id: String) -> void: _is_dialogue_locked = false Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) ## Liefert die aktuelle Kamera-Distanz in Metern für das Debug-Overlay. func get_camera_zoom() -> float: return _spring_arm.spring_length ## Liefert den aktuellen Kamera-Pitch in Radiant (negativ = Blick nach ## unten); das Nerven-System des Gauntlet liest daran den bewussten Blick ## in die Tiefe ab. func get_camera_pitch() -> float: return _spring_arm.rotation.x ## Liefert den Namen des aktiven Bewegungszustands für Debug-Zwecke. func get_movement_state_name() -> String: return MovementState.keys()[_state] ## Normale Bewegung: Schwerkraft, kamerarelatives Laufen mit Sprint und ## Sprung, danach Slide-Einstieg und Kletter-Kantenerkennung prüfen. func _process_normal(delta: float) -> void: if not is_on_floor(): velocity.y -= _gravity * delta elif Input.is_action_just_pressed("jump"): velocity.y = JUMP_SPEED var input_dir := Input.get_vector("move_left", "move_right", "move_forward", "move_back") var direction := _camera_pivot.global_transform.basis * Vector3(input_dir.x, 0.0, input_dir.y) direction.y = 0.0 var speed := SPRINT_SPEED if Input.is_action_pressed("sprint") else WALK_SPEED if direction.length_squared() > 0.0: velocity.x = direction.x * speed velocity.z = direction.z * speed var target_yaw := atan2(-direction.x, -direction.z) _mesh.rotation.y = lerp_angle(_mesh.rotation.y, target_yaw, minf(MESH_TURN_SPEED * delta, 1.0)) else: velocity.x = move_toward(velocity.x, 0.0, STOP_SPEED * delta) velocity.z = move_toward(velocity.z, 0.0, STOP_SPEED * delta) velocity.x += external_push.x velocity.z += external_push.z move_and_slide() if is_on_floor() and Input.is_action_just_pressed("slide"): _try_start_slide() elif not is_on_floor() and is_on_wall() and direction.length_squared() > 0.0: _try_start_climb(direction.normalized()) ## Startet den Slide, wenn genug horizontale Geschwindigkeit vorhanden ist: ## Impuls in Bewegungsrichtung proportional zur aktuellen Geschwindigkeit, ## Kapsel- und Mesh-Höhe reduziert. Kein Slide im Stand. func _try_start_slide() -> void: var horizontal := Vector3(velocity.x, 0.0, velocity.z) if horizontal.length() < SLIDE_MIN_ENTRY_SPEED: return _slide_direction = horizontal.normalized() _slide_start_speed = maxf(horizontal.length() * SLIDE_SPEED_BOOST, SLIDE_MIN_SPEED) _slide_time = 0.0 _apply_body_height(SLIDE_CAPSULE_HEIGHT, SLIDE_MESH_SQUASH) _state = MovementState.SLIDING ## Slide-Verlauf: Geschwindigkeit fällt über SLIDE_DURATION auf Gehtempo, ## dann Rückkehr in den normalen Zustand. Wände beenden den Slide sofort. func _process_slide(delta: float) -> void: _slide_time += delta var progress := clampf(_slide_time / SLIDE_DURATION, 0.0, 1.0) var speed := lerpf(_slide_start_speed, WALK_SPEED, progress) velocity.x = _slide_direction.x * speed velocity.z = _slide_direction.z * speed if not is_on_floor(): velocity.y -= _gravity * delta move_and_slide() if progress >= 1.0 or is_on_wall(): _end_slide() ## Beendet den Slide und stellt Kapsel- und Mesh-Höhe wieder her. func _end_slide() -> void: _apply_body_height(STAND_CAPSULE_HEIGHT, 1.0) _state = MovementState.NORMAL ## Setzt Kapselhöhe und Mesh-Stauchung gemeinsam und hält dabei beide ## Unterkanten auf Bodenniveau, indem die Mittelpunkte mitwandern. func _apply_body_height(capsule_height: float, mesh_scale: float) -> void: _capsule.height = capsule_height _collision_shape.position.y = capsule_height / 2.0 _mesh.scale.y = mesh_scale _mesh.position.y = STAND_CAPSULE_HEIGHT / 2.0 * mesh_scale ## Prüft im Sprung per Raycast, ob vor dem Spieler eine Kante unterhalb der ## Maximalhöhe mit freiem Platz darüber liegt, und startet das Hochziehen. ## move_direction ist die horizontale Bewegungsrichtung des Spielers. func _try_start_climb(move_direction: Vector3) -> void: var wall_normal := get_wall_normal() wall_normal.y = 0.0 if wall_normal.length_squared() < 0.5: return wall_normal = wall_normal.normalized() if move_direction.dot(-wall_normal) < 0.3: return var into_wall := -wall_normal var space := get_world_3d().direct_space_state var probe_top := global_position + Vector3.UP * (CLIMB_MAX_LEDGE_HEIGHT + CLIMB_PROBE_MARGIN) + into_wall * CLIMB_FORWARD_PROBE var ledge_query := PhysicsRayQueryParameters3D.create(probe_top, probe_top + Vector3.DOWN * CLIMB_MAX_LEDGE_HEIGHT, collision_mask, [get_rid()]) var ledge_hit := space.intersect_ray(ledge_query) if ledge_hit.is_empty(): return var ledge_height: float = ledge_hit["position"].y - global_position.y if ledge_height < CLIMB_MIN_LEDGE_HEIGHT or ledge_height > CLIMB_MAX_LEDGE_HEIGHT: return var landing: Vector3 = ledge_hit["position"] + into_wall * CLIMB_LANDING_INSET landing.y = ledge_hit["position"].y + 0.05 var headroom_query := PhysicsRayQueryParameters3D.create(landing + Vector3.UP * 0.1, landing + Vector3.UP * CLIMB_HEADROOM, collision_mask, [get_rid()]) if not space.intersect_ray(headroom_query).is_empty(): return _climb_start = global_position _climb_corner = Vector3(global_position.x, landing.y, global_position.z) _climb_target = landing _climb_time = 0.0 velocity = Vector3.ZERO _state = MovementState.CLIMBING ## Kletter-Verlauf in zwei Phasen: erst senkrecht auf Kantenhöhe, dann ## horizontal auf die Kante, anschließend zurück in normale Bewegung. func _process_climb(delta: float) -> void: _climb_time += delta var progress := clampf(_climb_time / CLIMB_DURATION, 0.0, 1.0) if progress < CLIMB_VERTICAL_PHASE: global_position = _climb_start.lerp(_climb_corner, progress / CLIMB_VERTICAL_PHASE) else: var lateral := (progress - CLIMB_VERTICAL_PHASE) / (1.0 - CLIMB_VERTICAL_PHASE) global_position = _climb_corner.lerp(_climb_target, lateral) if progress >= 1.0: velocity = Vector3.ZERO _state = MovementState.NORMAL ## Dreht die Kamera um yaw_delta (horizontal, am Pivot) und pitch_delta ## (vertikal, am SpringArm, begrenzt auf PITCH_MIN..PITCH_MAX). Beide Werte ## in Radiant. func _rotate_camera(yaw_delta: float, pitch_delta: float) -> void: _camera_pivot.rotation.y = wrapf(_camera_pivot.rotation.y + yaw_delta, -PI, PI) _spring_arm.rotation.x = clampf(_spring_arm.rotation.x + pitch_delta, PITCH_MIN, PITCH_MAX) ## Liest den rechten Stick des ersten aktiven Controllers und dreht die ## Kamera zeitbasiert. func _apply_stick_look(delta: float) -> void: var stick := Vector2( _read_joy_axis(JOY_AXIS_RIGHT_X), _read_joy_axis(JOY_AXIS_RIGHT_Y) ) if stick != Vector2.ZERO: _rotate_camera(-stick.x * STICK_LOOK_SPEED * delta, -stick.y * STICK_LOOK_SPEED * delta) ## Zoomt kontinuierlich, solange eine Schultertaste gehalten wird. func _apply_button_zoom(delta: float) -> void: var zoom_input := Input.get_action_strength("camera_zoom_out") - Input.get_action_strength("camera_zoom_in") if zoom_input != 0.0: _target_zoom = clampf(_target_zoom + zoom_input * ZOOM_BUTTON_SPEED * delta, ZOOM_MIN, ZOOM_MAX) ## Führt die SpringArm-Länge weich an das Zoom-Ziel heran. func _apply_zoom_smoothing(delta: float) -> void: _spring_arm.spring_length = lerpf(_spring_arm.spring_length, _target_zoom, minf(ZOOM_SMOOTHING * delta, 1.0)) ## Liest eine Joypad-Achse über alle verbundenen Controller und liefert den ## ersten Wert außerhalb der Deadzone, sonst 0. func _read_joy_axis(axis: JoyAxis) -> float: for device in Input.get_connected_joypads(): var value := Input.get_joy_axis(device, axis) if absf(value) > STICK_DEADZONE: return value return 0.0