- Charakter-Anlage (character_creation.tscn): Namenseingabe mit Default Tyrveil, Enter/confirm bestaetigt, cancel zurueck; Controller nutzt den Tastatur-Fallback mit bestaetigbarem Default (virtuelle Tastatur bewusst ausgelassen, nur Mobile/Web nativ); Name in GameState.player_name, erscheint in der Dialog-Box - Neues Spiel: Hauptmenue -> Charakter-Anlage -> Viadukt -> (Platzhalter- Uebergang) Reiterquadrant; Fortsetzen unveraendert - Viadukt (scenes/viaduct): vier kurze Segmente - schmaler Steg mit Sprung-Luecke und Gelaender-Stuecken, Kletter-Engstelle (Mechanik aus Phase 1b), Wren-Moment, Endplattform mit Uebergang; cineastischer Kamera-Schwenk beim Betreten (player.play_camera_pan, SPEC 2) - Wren-Moment: nicht abbrechbarer Entscheidungspunkt ueber das bestehende Dialog-System (can_abort:false sperrt cancel UND dialogue_abort); beide Optionen retten Wren (fixer Ausgang laut STORY.md), Klinge/Herz -10/+10, Beziehung +1/+3, Wahl als Story-Flag viaduct_wren_rescue (neues gespeichertes story_flags-Muster im GameState) - Permadeath: KillZone unter dem Steg - AN: Game Over ins Hauptmenue, AUS: Respawn am zuletzt erreichten Segment-Checkpoint - DialogueSystem: story_flag-Options-Tag, is_abort_allowed, Spielername aus GameState in der Box - .idea/ in .gitignore aufgenommen - Headless verifiziert (23 Checks): Namensfluss, Pan-Sperre, Respawn, Abbruch-Sperre im Wren-Moment, beide Pfade inkl. Flags, Endübergang, Game Over bei Permadeath AN Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
336 lines
13 KiB
GDScript
336 lines
13 KiB
GDScript
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 _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:
|
|
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)
|
|
|
|
|
|
## 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; 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
|
|
|
|
|
|
## Gibt Bewegung und Look nach Dialogende wieder frei.
|
|
func _on_dialogue_finished(_dialogue_id: String) -> void:
|
|
_is_dialogue_locked = false
|
|
|
|
|
|
## Liefert die aktuelle Kamera-Distanz in Metern für das Debug-Overlay.
|
|
func get_camera_zoom() -> float:
|
|
return _spring_arm.spring_length
|
|
|
|
|
|
## 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)
|
|
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
|