V.0.6.1
This commit is contained in:
parent
6f92fc0ae0
commit
bc410156ee
41 changed files with 1058 additions and 743 deletions
|
|
@ -24,17 +24,17 @@ var grip := 100.0
|
|||
var _player: CharacterBody3D
|
||||
var _nerve: Node
|
||||
var _mode: Node
|
||||
var _course_z := -4.0
|
||||
var _course_min_x := -20.0
|
||||
var _progress_height := 0.0
|
||||
var _bar: ProgressBar
|
||||
|
||||
|
||||
## Verknüpft Spieler, Nerven-System und Modus und baut die HUD-Leiste.
|
||||
func setup(player: CharacterBody3D, nerve_system: Node, gauntlet_mode: Node, course_z: float) -> void:
|
||||
func setup(player: CharacterBody3D, nerve_system: Node, gauntlet_mode: Node, course_min_x: float) -> void:
|
||||
_player = player
|
||||
_nerve = nerve_system
|
||||
_mode = gauntlet_mode
|
||||
_course_z = course_z
|
||||
_course_min_x = course_min_x
|
||||
grip = grip_max
|
||||
_build_hud()
|
||||
|
||||
|
|
@ -56,7 +56,7 @@ func reset_grip() -> void:
|
|||
func _physics_process(delta: float) -> void:
|
||||
if _player == null or DialogueSystem.is_dialogue_active:
|
||||
return
|
||||
var is_in_course: bool = _player.global_position.z < _course_z
|
||||
var is_in_course: bool = _player.global_position.x > _course_min_x or _player.global_position.y > 2.0
|
||||
if not is_in_course:
|
||||
_apply_grip(grip + grip_regen_rate * delta)
|
||||
return
|
||||
|
|
|
|||
|
|
@ -21,17 +21,17 @@ var _player: CharacterBody3D
|
|||
var _nerve: Node
|
||||
var _mode: Node
|
||||
var _dragons: Array[Node3D] = []
|
||||
var _course_z := -4.0
|
||||
var _course_min_x := -20.0
|
||||
var _timer := 0.0
|
||||
|
||||
|
||||
## Verknüpft Spieler, Nerven-System, Modus und die Drachen-Silhouetten.
|
||||
func setup(player: CharacterBody3D, nerve_system: Node, gauntlet_mode: Node, dragons: Array[Node3D], course_z: float) -> void:
|
||||
func setup(player: CharacterBody3D, nerve_system: Node, gauntlet_mode: Node, dragons: Array[Node3D], course_min_x: float) -> void:
|
||||
_player = player
|
||||
_nerve = nerve_system
|
||||
_mode = gauntlet_mode
|
||||
_dragons = dragons
|
||||
_course_z = course_z
|
||||
_course_min_x = course_min_x
|
||||
_reset_timer()
|
||||
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ func _physics_process(delta: float) -> void:
|
|||
return
|
||||
if DialogueSystem.is_dialogue_active or _player.is_control_locked():
|
||||
return
|
||||
if _player.global_position.z > _course_z:
|
||||
if _player.global_position.x <= _course_min_x and _player.global_position.y <= 2.0:
|
||||
return
|
||||
_timer -= delta
|
||||
if _timer <= 0.0:
|
||||
|
|
|
|||
|
|
@ -1,30 +1,32 @@
|
|||
extends Node3D
|
||||
## Ablauf-Steuerung des Gauntlet (CR-002: vertikaler Kletter-Parcours,
|
||||
## Ablauf-Steuerung des Gauntlet (CR-003: Serpentine über fünf Terrassen,
|
||||
## Phase 4c: Wendepunkt, STORY.md Abschnitte 3 und 5).
|
||||
##
|
||||
## Der Parcours besteht aus fünf Ascent-Sub-Scenes an der Felswand,
|
||||
## verbunden über schulterbreite Kies-Pfade; unten kaschiert Nebel den
|
||||
## tausende Fuß tiefen Abgrund, oben warten die Drachen am Eingang der
|
||||
## Box-Canyon. Komponenten am Root: gauntlet_mode (training/exam +
|
||||
## manipulated), climb_controller (Griff + Descent-Sperre),
|
||||
## safety_rope_system (Seilfang-QTE, +30 s), run_timer (Zeitlauf),
|
||||
## rival_climbers (Live-Tode im Ernstlauf), nerve_system und
|
||||
## dragon_distraction (baseline aus; per CR-003 ohne Wind-Ruck und ohne
|
||||
## Gegensteuer-QTE — Wind gehört zum Viadukt, nicht zum Gauntlet). Die
|
||||
## Treppe neben dem Lauf ist rein visuell (im Ernstlauf tabu, Zugang erst
|
||||
## nach der Präsentation).
|
||||
## Der Parcours ist eine Serpentine: fünf Terrassen, vertikal versetzt in
|
||||
## die Felswand geschnitten, die Laufrichtung wechselt pro Terrasse
|
||||
## (Zickzack), verbunden durch schulterbreite Kies-Kurven an den
|
||||
## Terrassen-Enden (echte Laufwege mit Zeitanteil, Rast und Blick auf den
|
||||
## Abgrund). Terrasse 1–4 sind Lauf-, Balance- und Hangel-Hindernisse;
|
||||
## geklettert wird erst im Finale (Felsspalt-Kamin, Rampe, Felskante ->
|
||||
## Box-Canyon mit den Drachen). Die offene Außenseite ist Absturzkante:
|
||||
## Im Sturzkorridor davor hängt das Seilfeld (safety_rope_field) — der
|
||||
## Seilfang greift im freien Fall, jede Berührung kostet Zeit, an den
|
||||
## Rolling Logs (Terrasse 4) gibt es keine Seile. Komponenten am Root:
|
||||
## gauntlet_mode, climb_controller (Griff + Descent-Sperre im Ernstlauf),
|
||||
## safety_rope_field, run_timer, rival_climbers, nerve_system,
|
||||
## dragon_distraction (baseline aus, ohne Wind-Ruck/QTE).
|
||||
##
|
||||
## Story (Phase 4c, unverändert): Der erste Lauf ist der manipulierte
|
||||
## Ernstlauf — Marens Tod ist FIX und unabhängig vom Permadeath-Toggle.
|
||||
## Sequenz am Sammel-Absatz vor Ascent 5: Intervention -> Einsturz, Wren
|
||||
## Sequenz am Terrassen-5-Anfang: Intervention -> Einsturz, Wren
|
||||
## gerettet, Maren getroffen -> Sterbeszene mit Wahrheit 1 und 2 ->
|
||||
## Trauer-Wahl. Nach dem Wendepunkt ist der Lauf freies Training ohne
|
||||
## Rivalen. story_hook_reached feuert an jedem Ascent-Übergang (Anker für
|
||||
## den separaten Phase-4-Story-CR).
|
||||
## Trauer-Wahl. Danach ist der Lauf freies Training ohne Rivalen.
|
||||
## story_hook_reached feuert an jedem Terrassen-Übergang (Anker für den
|
||||
## separaten Phase-4-Story-CR).
|
||||
|
||||
signal ascent_completed(index: int)
|
||||
signal terrace_completed(index: int)
|
||||
signal obstacle_cleared(obstacle_id: String)
|
||||
signal story_hook_reached(ascent_index: int)
|
||||
signal story_hook_reached(terrace_index: int)
|
||||
|
||||
const MAIN_MENU_SCENE := "res://scenes/ui/main_menu.tscn"
|
||||
const START_PATH := "res://data/dialogue/gauntlet_start.json"
|
||||
|
|
@ -32,52 +34,44 @@ const INTERVENTION_PATH := "res://data/dialogue/gauntlet_intervention.json"
|
|||
const DEATH_PATH := "res://data/dialogue/gauntlet_death.json"
|
||||
const GRIEF_PATH := "res://data/dialogue/gauntlet_grief.json"
|
||||
const TUNING_PATH := "res://data/gauntlet/gauntlet_tuning.tres"
|
||||
const ASCENT_CONFIG_PATHS: Array[String] = [
|
||||
"res://data/gauntlet/ascent_1.tres",
|
||||
"res://data/gauntlet/ascent_2.tres",
|
||||
"res://data/gauntlet/ascent_3.tres",
|
||||
"res://data/gauntlet/ascent_4.tres",
|
||||
"res://data/gauntlet/ascent_5.tres",
|
||||
const TERRACE_CONFIG_PATHS: Array[String] = [
|
||||
"res://data/gauntlet/terrace_1.tres",
|
||||
"res://data/gauntlet/terrace_2.tres",
|
||||
"res://data/gauntlet/terrace_3.tres",
|
||||
"res://data/gauntlet/terrace_4.tres",
|
||||
"res://data/gauntlet/terrace_5.tres",
|
||||
]
|
||||
const BEHAVIOR_TUNABLES: Array[String] = [
|
||||
"log_spin_speed", "wheel_speed", "wheel_exit_window", "buoy_swing_period",
|
||||
"launch_window", "momentum_charge_time", "hangel_rhythm_window",
|
||||
"shake_amplitude", "shake_frequency", "roll_speed", "min_ascend_speed",
|
||||
"crush_grace", "chimney_brace_tolerance", "chimney_drift_speed",
|
||||
"ramp_min_momentum",
|
||||
]
|
||||
const MAREN_ARRIVAL_POSITION := Vector3(1, 26.45, -88.5)
|
||||
const MAREN_FALL_POSITION := Vector3(0.8, 26.45, -89.8)
|
||||
const WREN_SAFE_POSITION := Vector3(-1, 26.45, -88.5)
|
||||
const BASE_SPAWN := Vector3(0, 0.1, 2)
|
||||
const COURSE_START_Z := -4.0
|
||||
const GRAVEL_CENTERS: Array[Vector3] = [
|
||||
Vector3(0, 7.85, -26.5),
|
||||
Vector3(0, 13.85, -45),
|
||||
Vector3(0, 19.25, -73),
|
||||
Vector3(0, 26.15, -90),
|
||||
]
|
||||
const GRAVEL_SIZES: Array[Vector3] = [
|
||||
Vector3(0.9, 0.3, 4),
|
||||
Vector3(0.9, 0.3, 4),
|
||||
Vector3(0.9, 0.3, 4),
|
||||
Vector3(3, 0.3, 5),
|
||||
"log_spin_speed", "wheel_speed", "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",
|
||||
"roll_speed", "min_ascend_speed", "crush_grace",
|
||||
"chimney_brace_tolerance", "chimney_drift_speed", "ramp_min_momentum",
|
||||
]
|
||||
const MAREN_ARRIVAL_POSITION := Vector3(-17.5, 25.1, -0.2)
|
||||
const MAREN_FALL_POSITION := Vector3(-18.3, 25.1, -0.9)
|
||||
const WREN_SAFE_POSITION := Vector3(-16.5, 25.1, -0.2)
|
||||
const BASE_SPAWN := Vector3(-23, 0.1, -0.6)
|
||||
const COURSE_MIN_X := -20.0
|
||||
const TOP_CHECKPOINT := Vector3(10.5, 36.5, -0.6)
|
||||
const SPINE: Array[Vector3] = [
|
||||
Vector3(0, 0, -2), Vector3(0, 0.55, -6), Vector3(0, 5.3, -18),
|
||||
Vector3(0, 8, -24.5), Vector3(0, 8, -28.5), Vector3(0, 14, -43),
|
||||
Vector3(0, 14, -47), Vector3(0, 15.4, -61.8), Vector3(0, 19.4, -71),
|
||||
Vector3(0, 19.4, -75), Vector3(0, 26.3, -87.5), Vector3(0, 26.3, -92.5),
|
||||
Vector3(0, 32.6, -97.5), Vector3(0, 35.6, -103), Vector3(0, 37.6, -106),
|
||||
Vector3(-23, 0, -0.6), Vector3(0, 0.55, -0.6), Vector3(20.5, 0.5, -0.6),
|
||||
Vector3(21.8, 3, 2.9), Vector3(20.5, 6, -0.6), Vector3(-20.5, 6, -0.6),
|
||||
Vector3(-21.8, 9, 2.9), Vector3(-20.5, 12, -0.6), Vector3(20, 12.2, -0.6),
|
||||
Vector3(21.8, 15, 2.9), Vector3(20, 18, -0.6), Vector3(14.4, 18.5, -0.6),
|
||||
Vector3(1.2, 21.2, -0.6), Vector3(-20.5, 21.15, -0.6),
|
||||
Vector3(-21.8, 23, 2.9), Vector3(-19, 25, -0.6), Vector3(-5, 25, -0.6),
|
||||
Vector3(0, 31.3, -0.6), Vector3(4.4, 36.3, -0.6), Vector3(10, 36.3, -0.6),
|
||||
]
|
||||
const ASCENT_BREAKS := [-28.5, -47.0, -71.0, -87.5]
|
||||
const NO_ROPE_RANGE := Vector2(-87.5, -75.0)
|
||||
const RIVAL_CRUSH_ZONE := Vector2(-86.0, -76.0)
|
||||
const TERRACE_BREAKS := [5.9, 11.9, 17.9, 24.5]
|
||||
const NO_ROPE_BAND := Vector2(17.4, 21.4)
|
||||
const RIVAL_CRUSH_BAND := Vector2(18.2, 21.4)
|
||||
|
||||
var _checkpoint_position := BASE_SPAWN
|
||||
var _has_intervention_run := false
|
||||
var _has_run_started := false
|
||||
var _reached_ascents: Dictionary = {}
|
||||
var _reached_terraces: Dictionary = {}
|
||||
var _player: CharacterBody3D
|
||||
var _dragons: Array[Node3D] = []
|
||||
|
||||
|
|
@ -86,33 +80,36 @@ var _dragons: Array[Node3D] = []
|
|||
@onready var _mode: Node = $GauntletMode
|
||||
@onready var _climb: Node = $ClimbController
|
||||
@onready var _nerve: Node = $NerveSystem
|
||||
@onready var _ropes: Node3D = $SafetyRopeSystem
|
||||
@onready var _ropes: Node3D = $SafetyRopeField
|
||||
@onready var _timer: Node = $RunTimer
|
||||
@onready var _rivals: Node3D = $RivalClimbers
|
||||
@onready var _distraction: Node = $DragonDistraction
|
||||
@onready var _curves: Array[Node3D] = [$Curve1, $Curve2, $Curve3, $Curve4]
|
||||
|
||||
|
||||
## Baut Kurs-Umgebung, lädt das Tuning, verdrahtet Komponenten und
|
||||
## Hindernisse und initialisiert Modus und Story-Zustand.
|
||||
## Baut Kurs-Umgebung, lädt das Tuning, verdrahtet Komponenten, Kurven
|
||||
## und Hindernisse und initialisiert Modus und Story-Zustand.
|
||||
func _ready() -> void:
|
||||
_player = get_tree().get_first_node_in_group("player")
|
||||
_build_course()
|
||||
_apply_tuning()
|
||||
if _player != null:
|
||||
_nerve.setup(_player, COURSE_START_Z)
|
||||
_climb.setup(_player, _nerve, _mode, COURSE_START_Z)
|
||||
var anchors: Array[Vector3] = [Vector3(0, 0, 0)]
|
||||
for center in GRAVEL_CENTERS:
|
||||
anchors.append(Vector3(center.x, center.y + 0.15, center.z))
|
||||
anchors.append(Vector3(0, 37.6, -106))
|
||||
var no_rope_ranges: Array[Vector2] = [NO_ROPE_RANGE]
|
||||
_ropes.setup(_player, _mode, SPINE, anchors, no_rope_ranges, COURSE_START_Z)
|
||||
_distraction.setup(_player, _nerve, _mode, _dragons, COURSE_START_Z)
|
||||
_nerve.setup(_player, COURSE_MIN_X)
|
||||
_climb.setup(_player, _nerve, _mode, COURSE_MIN_X)
|
||||
var anchors: Array[Vector3] = [Vector3(-23, 0, -0.6)]
|
||||
for curve in _curves:
|
||||
anchors.append(curve.get_exit_position())
|
||||
anchors.append(Vector3(10.5, 36.3, -0.6))
|
||||
var no_rope_bands: Array[Vector2] = [NO_ROPE_BAND]
|
||||
_ropes.setup(_player, _mode, -20.0, 20.0, anchors, no_rope_bands)
|
||||
_distraction.setup(_player, _nerve, _mode, _dragons, COURSE_MIN_X)
|
||||
_wire_obstacles()
|
||||
for i in _curves.size():
|
||||
_curves[i].exit_reached.connect(_on_curve_exit.bind(i + 1))
|
||||
$KillZone.body_entered.connect(_on_kill_zone_entered)
|
||||
_climb.climber_fell.connect(_on_climber_fell)
|
||||
_ropes.rope_caught.connect(_on_rope_caught)
|
||||
_ropes.catch_failed.connect(_on_catch_failed)
|
||||
_ropes.rope_touched.connect(_on_rope_touched)
|
||||
_ropes.rope_missed.connect(_on_rope_missed)
|
||||
_rivals.rival_fell.connect(_on_rival_fell)
|
||||
_init_mode_and_story()
|
||||
|
||||
|
|
@ -123,7 +120,7 @@ func _physics_process(_delta: float) -> void:
|
|||
return
|
||||
if not _mode.is_exam() or DialogueSystem.is_dialogue_active:
|
||||
return
|
||||
if _player.global_position.z < -5.0:
|
||||
if _player.global_position.x > -19.5:
|
||||
_has_run_started = true
|
||||
_timer.start_run()
|
||||
_rivals.start()
|
||||
|
|
@ -145,7 +142,7 @@ func _init_mode_and_story() -> void:
|
|||
_mode.manipulated = true
|
||||
_apply_manipulated_preset()
|
||||
var haste: float = _mode.rival_haste_scale()
|
||||
_rivals.setup(SPINE, PackedFloat32Array(ASCENT_BREAKS), RIVAL_CRUSH_ZONE, haste)
|
||||
_rivals.setup(SPINE, PackedFloat32Array(TERRACE_BREAKS), RIVAL_CRUSH_BAND, haste)
|
||||
$InterventionTrigger.body_entered.connect(_on_intervention_entered)
|
||||
_play_opening()
|
||||
|
||||
|
|
@ -163,15 +160,17 @@ func _play_opening() -> void:
|
|||
})
|
||||
|
||||
|
||||
## Lädt gauntlet_tuning.tres und die Ascent-Configs und verteilt die
|
||||
## Lädt gauntlet_tuning.tres und die Terrassen-Configs und verteilt die
|
||||
## Werte an Komponenten und Hindernisse (Verhaltens-Tunables; Geometrie-
|
||||
## Werte stehen als Overrides direkt in den Ascent-Szenen).
|
||||
## Werte stehen als Overrides direkt in den Terrassen-/Kurven-Szenen).
|
||||
func _apply_tuning() -> void:
|
||||
var tuning: GauntletTuning = load(TUNING_PATH)
|
||||
_ropes.rope_spacing = tuning.rope_spacing
|
||||
_ropes.rope_catch_radius = tuning.rope_catch_radius
|
||||
_ropes.rope_catch_window = tuning.rope_catch_window
|
||||
_ropes.rope_recover_time = tuning.rope_recover_time
|
||||
_ropes.rope_time_penalty = tuning.rope_time_penalty
|
||||
_ropes.corridor_z = tuning.corridor_width - 0.6
|
||||
_ropes.course_min_x = COURSE_MIN_X
|
||||
_climb.grip_max = tuning.grip_max
|
||||
_climb.grip_drain_rate = tuning.grip_drain_rate
|
||||
_climb.grip_regen_rate = tuning.grip_regen_rate
|
||||
|
|
@ -191,28 +190,27 @@ func _apply_tuning() -> void:
|
|||
_distraction.distraction_enabled_baseline = tuning.distraction_enabled_baseline
|
||||
_distraction.distraction_interval_min = tuning.distraction_interval_min
|
||||
_distraction.distraction_interval_max = tuning.distraction_interval_max
|
||||
for i in ASCENT_CONFIG_PATHS.size():
|
||||
var config: AscentConfig = load(ASCENT_CONFIG_PATHS[i])
|
||||
var ascent := get_node("Ascent%d" % (i + 1))
|
||||
for obstacle in ascent.get_children():
|
||||
for i in TERRACE_CONFIG_PATHS.size():
|
||||
var config: TerraceConfig = load(TERRACE_CONFIG_PATHS[i])
|
||||
var terrace := get_node("Terrace%d" % (i + 1))
|
||||
for obstacle in terrace.get_children():
|
||||
if obstacle is GauntletObstacle:
|
||||
_apply_config_to_obstacle(config, obstacle)
|
||||
|
||||
|
||||
## Überträgt die Verhaltens-Tunables einer Ascent-Config auf ein Hindernis.
|
||||
func _apply_config_to_obstacle(config: AscentConfig, obstacle: GauntletObstacle) -> void:
|
||||
## Überträgt die Verhaltens-Tunables einer Terrassen-Config auf ein
|
||||
## Hindernis.
|
||||
func _apply_config_to_obstacle(config: TerraceConfig, obstacle: GauntletObstacle) -> void:
|
||||
for property in BEHAVIOR_TUNABLES:
|
||||
if property in obstacle:
|
||||
obstacle.set(property, config.get(property))
|
||||
|
||||
|
||||
## Verschärft die Hindernisse gemäß manipulated-Preset (Zeitfenster,
|
||||
## Rollgeschwindigkeit); Rival- und Ablenkungs-Raffung übernehmen die
|
||||
## Komponenten selbst über die Modus-Skalen.
|
||||
## Rollgeschwindigkeit); Rad-Fenster, Rival- und Ablenkungs-Raffung
|
||||
## übernehmen die Komponenten selbst über die Modus-Skalen.
|
||||
func _apply_manipulated_preset() -> void:
|
||||
for obstacle in get_tree().get_nodes_in_group("gauntlet_obstacle"):
|
||||
if "wheel_exit_window" in obstacle:
|
||||
obstacle.wheel_exit_window *= _mode.window_scale()
|
||||
if "launch_window" in obstacle:
|
||||
obstacle.launch_window *= _mode.window_scale()
|
||||
if "roll_speed" in obstacle:
|
||||
|
|
@ -229,33 +227,24 @@ func _wire_obstacles() -> void:
|
|||
obstacle.crushed.connect(_on_crushed)
|
||||
|
||||
|
||||
## Baut die Kurs-Umgebung: Fuß-Plattform, Kies-Pfade mit Rast-/Checkpoint-
|
||||
## Zonen, Box-Canyon-Plattform mit Drachen, Treppen-Visual und Felswand.
|
||||
## Baut die Kurs-Umgebung: Fuß-Plattform, Felswand, Box-Canyon-Plattform
|
||||
## mit Engpass und Drachen sowie Rast-Zonen an Fuß und Ziel.
|
||||
func _build_course() -> void:
|
||||
_build_platform(Vector3(0, -0.5, 0), Vector3(8, 1, 8))
|
||||
_build_rest_zone(Vector3(0, 1.5, 0), Vector3(8, 3, 8), 0)
|
||||
for i in GRAVEL_CENTERS.size():
|
||||
_build_platform(GRAVEL_CENTERS[i], GRAVEL_SIZES[i])
|
||||
var zone_size := GRAVEL_SIZES[i] + Vector3(0.4, 2.0, 0.4)
|
||||
var zone_center := GRAVEL_CENTERS[i] + Vector3(0, 1.0, 0)
|
||||
_build_rest_zone(zone_center, zone_size, i + 1)
|
||||
_build_platform(Vector3(0, 37.1, -109), Vector3(10, 1, 10))
|
||||
_build_rest_zone(Vector3(0, 38.6, -109), Vector3(10, 2, 10), 5)
|
||||
for x in [-3.2, 3.2]:
|
||||
add_child(_make_mesh(Vector3(2.5, 5, 4), Vector3(x, 40.1, -111), Color(0.4, 0.38, 0.36)))
|
||||
var dragon_spots := [Vector3(-3, 37.6, -112), Vector3(-1, 37.6, -112.6), Vector3(1.5, 37.6, -112.2), Vector3(3.5, 37.6, -111.6)]
|
||||
_build_platform(Vector3(-23.5, -0.5, -0.6), Vector3(6, 1, 6))
|
||||
_build_rest_zone(Vector3(-23.5, 1.5, -0.6), Vector3(6, 3, 6), false)
|
||||
_build_platform(Vector3(10.5, 35.8, -0.6), Vector3(12, 1, 10))
|
||||
_build_rest_zone(Vector3(10.5, 37.5, -0.6), Vector3(12, 2.4, 10), true)
|
||||
add_child(_make_mesh(Vector3(7, 4, 1.4), Vector3(9, 38.3, -4.8), Color(0.4, 0.38, 0.36)))
|
||||
add_child(_make_mesh(Vector3(7, 4, 1.4), Vector3(9, 38.3, 3.6), Color(0.4, 0.38, 0.36)))
|
||||
var dragon_spots := [Vector3(13, 36.3, -3.5), Vector3(15, 36.3, -2), Vector3(14, 36.3, 1.5), Vector3(16, 36.3, 0)]
|
||||
for spot in dragon_spots:
|
||||
var dragon := _make_dragon(spot)
|
||||
add_child(dragon)
|
||||
_dragons.append(dragon)
|
||||
var stairs := _make_mesh(Vector3(1.2, 0.5, 116), Vector3(5, 18.8, -54), Color(0.5, 0.48, 0.46))
|
||||
stairs.rotation.x = -atan2(37.6, 108.0)
|
||||
add_child(stairs)
|
||||
var cliff := _make_mesh(Vector3(1, 52, 124), Vector3(3.9, 20, -55), Color(0.36, 0.34, 0.33))
|
||||
add_child(cliff)
|
||||
add_child(_make_mesh(Vector3(56, 42, 1), Vector3(0, 17, -3.1), Color(0.36, 0.34, 0.33)))
|
||||
|
||||
|
||||
## Baut eine begehbare Plattform (Kies-Pfad, Fuß, Box-Canyon).
|
||||
## Baut eine begehbare Plattform (Fuß, Box-Canyon).
|
||||
func _build_platform(center: Vector3, size: Vector3) -> void:
|
||||
var body := StaticBody3D.new()
|
||||
body.position = center
|
||||
|
|
@ -268,9 +257,9 @@ func _build_platform(center: Vector3, size: Vector3) -> void:
|
|||
add_child(body)
|
||||
|
||||
|
||||
## Baut eine Rast-Zone (Gruppe gauntlet_rest); index 1..4 sind zugleich
|
||||
## Ascent-Übergänge/Checkpoints, 0 ist der Fuß, 5 die Box-Canyon.
|
||||
func _build_rest_zone(center: Vector3, size: Vector3, index: int) -> void:
|
||||
## Baut eine Rast-Zone (Gruppe gauntlet_rest); die Ziel-Zone schließt
|
||||
## zusätzlich den Lauf ab.
|
||||
func _build_rest_zone(center: Vector3, size: Vector3, is_finish: bool) -> void:
|
||||
var area := Area3D.new()
|
||||
area.collision_layer = 0
|
||||
area.collision_mask = 2
|
||||
|
|
@ -281,7 +270,8 @@ func _build_rest_zone(center: Vector3, size: Vector3, index: int) -> void:
|
|||
box.size = size
|
||||
shape.shape = box
|
||||
area.add_child(shape)
|
||||
area.body_entered.connect(_on_rest_zone_entered.bind(index, center.y))
|
||||
if is_finish:
|
||||
area.body_entered.connect(_on_finish_entered)
|
||||
add_child(area)
|
||||
|
||||
|
||||
|
|
@ -302,71 +292,68 @@ func _make_mesh(size: Vector3, position_offset: Vector3, color: Color) -> MeshIn
|
|||
func _make_dragon(spot: Vector3) -> Node3D:
|
||||
var dragon := Node3D.new()
|
||||
dragon.position = spot
|
||||
var body := _make_mesh(Vector3(1.6, 1.4, 2.8), Vector3(0, 0.7, 0), Color(0.18, 0.14, 0.16))
|
||||
dragon.add_child(body)
|
||||
var neck := _make_mesh(Vector3(0.5, 1.6, 0.5), Vector3(0, 1.8, 1.2), Color(0.18, 0.14, 0.16))
|
||||
dragon.add_child(neck)
|
||||
dragon.add_child(_make_mesh(Vector3(1.6, 1.4, 2.8), Vector3(0, 0.7, 0), Color(0.18, 0.14, 0.16)))
|
||||
dragon.add_child(_make_mesh(Vector3(0.5, 1.6, 0.5), Vector3(0, 1.8, 1.2), Color(0.18, 0.14, 0.16)))
|
||||
return dragon
|
||||
|
||||
|
||||
## Ascent-Übergang betreten: Checkpoint (Training), Fortschritts-Höhe für
|
||||
## die Descent-Sperre, ascent_completed + story_hook_reached einmalig.
|
||||
func _on_rest_zone_entered(body: Node3D, index: int, top_y: float) -> void:
|
||||
## Kurven-Ausstieg erreicht: Checkpoint (Training), Fortschritts-Höhe für
|
||||
## die Descent-Sperre, terrace_completed + story_hook_reached einmalig.
|
||||
func _on_curve_exit(index: int) -> void:
|
||||
var exit_position: Vector3 = _curves[index - 1].get_exit_position()
|
||||
_climb.set_progress_height(exit_position.y)
|
||||
if _mode.is_training():
|
||||
_checkpoint_position = exit_position
|
||||
if _reached_terraces.has(index):
|
||||
return
|
||||
_reached_terraces[index] = true
|
||||
terrace_completed.emit(index)
|
||||
story_hook_reached.emit(index)
|
||||
|
||||
|
||||
## Ziel erreicht (Box-Canyon): Terrasse 5 abschließen und die Uhr stoppen.
|
||||
func _on_finish_entered(body: Node3D) -> void:
|
||||
if not body.is_in_group("player"):
|
||||
return
|
||||
_climb.set_progress_height(top_y)
|
||||
_climb.set_progress_height(36.3)
|
||||
if _mode.is_training():
|
||||
_checkpoint_position = _rest_checkpoint(index)
|
||||
if index == 0 or _reached_ascents.has(index):
|
||||
_checkpoint_position = TOP_CHECKPOINT
|
||||
if _reached_terraces.has(5):
|
||||
return
|
||||
_reached_ascents[index] = true
|
||||
ascent_completed.emit(index)
|
||||
story_hook_reached.emit(index)
|
||||
if index == 5:
|
||||
_timer.stop_run()
|
||||
_reached_terraces[5] = true
|
||||
terrace_completed.emit(5)
|
||||
story_hook_reached.emit(5)
|
||||
_timer.stop_run()
|
||||
|
||||
|
||||
## Liefert den Respawn-Punkt einer Rast-Zone (Fuß, Kies-Pfad 1..4,
|
||||
## Box-Canyon).
|
||||
func _rest_checkpoint(index: int) -> Vector3:
|
||||
if index == 0:
|
||||
return BASE_SPAWN
|
||||
if index <= 4:
|
||||
var center := GRAVEL_CENTERS[index - 1]
|
||||
return Vector3(center.x, center.y + 0.35, center.z)
|
||||
return Vector3(0, 37.7, -109)
|
||||
|
||||
|
||||
## Hindernis geschafft: Signal durchreichen; die Cliff Ledge beendet den
|
||||
## Kurs zusätzlich über die Box-Canyon-Rast-Zone.
|
||||
## Hindernis geschafft: Signal durchreichen.
|
||||
func _on_obstacle_cleared(obstacle_id: String) -> void:
|
||||
obstacle_cleared.emit(obstacle_id)
|
||||
|
||||
|
||||
## Fehlgriff an einem Hindernis: Seilfang-Versuch.
|
||||
## Fehlgriff an einem Hindernis: Seilfang-Versuch im Sturz.
|
||||
func _on_obstacle_fall(_source_id: String) -> void:
|
||||
_ropes.attempt_catch()
|
||||
|
||||
|
||||
## Griff leer, Descent-Sperre oder Gegensteuer-QTE verloren: Seilfang.
|
||||
## Griff leer oder Descent-Sperre gerissen: Seilfang-Versuch.
|
||||
func _on_climber_fell() -> void:
|
||||
_ropes.attempt_catch()
|
||||
|
||||
|
||||
## Seilfang geglückt: Zeitstrafe auf den Lauf.
|
||||
func _on_rope_caught(time_penalty: float) -> void:
|
||||
## Seilberührung (Fang oder Streifen): Zeitstrafe auf den Lauf.
|
||||
func _on_rope_touched(time_penalty: float) -> void:
|
||||
if _timer.is_running:
|
||||
_timer.add_penalty(time_penalty)
|
||||
|
||||
|
||||
## Seilfang gescheitert oder unmöglich (No-Rope-Zone, kein Seil in
|
||||
## Reichweite): Death-State.
|
||||
func _on_catch_failed() -> void:
|
||||
## Kein Seil erreicht (verpasst oder No-Rope-Zone): Death-State.
|
||||
func _on_rope_missed() -> void:
|
||||
_handle_death()
|
||||
|
||||
|
||||
## Rival-Sturz in Sicht: Nerven-Anstieg.
|
||||
func _on_rival_fell(_rival_id: int, _ascent_index: int) -> void:
|
||||
func _on_rival_fell(_rival_id: int, _terrace_index: int) -> void:
|
||||
_nerve.add_nerve(_nerve.nerve_on_rival_fall)
|
||||
|
||||
|
||||
|
|
@ -402,8 +389,8 @@ func _handle_death() -> void:
|
|||
_player.global_position = _checkpoint_position
|
||||
|
||||
|
||||
## Startet den Wendepunkt einmalig, sobald Tyrveil den Sammel-Absatz vor
|
||||
## Ascent 5 erreicht.
|
||||
## Startet den Wendepunkt einmalig, sobald Tyrveil den Anfang von
|
||||
## Terrasse 5 erreicht.
|
||||
func _on_intervention_entered(body: Node3D) -> void:
|
||||
if not body.is_in_group("player"):
|
||||
return
|
||||
|
|
@ -448,7 +435,7 @@ func _run_climax(player: CharacterBody3D) -> void:
|
|||
_mode.manipulated = false
|
||||
_mode.set_mode(_mode.Mode.TRAINING)
|
||||
_rivals.stop()
|
||||
_checkpoint_position = Vector3(GRAVEL_CENTERS[3].x, GRAVEL_CENTERS[3].y + 0.35, GRAVEL_CENTERS[3].z)
|
||||
_checkpoint_position = Vector3(-19, 25.3, -0.6)
|
||||
|
||||
|
||||
## Legt Marens Mesh in Liegeposition; der Root bleibt aufrecht, damit
|
||||
|
|
|
|||
|
|
@ -1,17 +1,23 @@
|
|||
class_name GauntletTuning
|
||||
extends Resource
|
||||
## Globales Tuning des Gauntlet-Parcours (CR-002), daten-getrieben unter
|
||||
## data/gauntlet/gauntlet_tuning.tres.
|
||||
## Globales Tuning des Gauntlet-Parcours (CR-002/CR-003), daten-getrieben
|
||||
## unter data/gauntlet/gauntlet_tuning.tres.
|
||||
##
|
||||
## Bündelt die szenenweiten Werte: Sicherungsseile (Abstand, Fang-QTE,
|
||||
## Zeitstrafe), Zeitlauf, Nerven-System, Rival-Kadetten und
|
||||
## Drachen-Ablenkung. Die Hindernis-Werte pro Ascent liegen in den
|
||||
## ascent_N.tres (AscentConfig).
|
||||
## Bündelt die szenenweiten Werte: Seilfeld im Sturzkorridor, Kurven,
|
||||
## Zeitlauf, Griff, Nerven-System, Rival-Kadetten und Drachen-Ablenkung.
|
||||
## Die Hindernis-Werte pro Terrasse liegen in den terrace_N.tres
|
||||
## (TerraceConfig).
|
||||
|
||||
@export var rope_spacing := 1.8
|
||||
@export var rope_catch_radius := 3.5
|
||||
@export var rope_catch_window := 0.7
|
||||
@export var rope_recover_time := 1.2
|
||||
@export var rope_time_penalty := 30.0
|
||||
@export var corridor_width := 3.0
|
||||
|
||||
@export var terrace_height_offset := 6.0
|
||||
@export var terrace_width := 2.4
|
||||
@export var curve_length := 4.0
|
||||
@export var curve_width := 0.9
|
||||
|
||||
@export var grip_max := 100.0
|
||||
@export var grip_drain_rate := 3.5
|
||||
|
|
@ -30,7 +36,7 @@ extends Resource
|
|||
@export var rival_count := 5
|
||||
@export var rival_climb_speed := 1.6
|
||||
@export var rival_fall_schedule: PackedFloat32Array = PackedFloat32Array([18.0, 42.0])
|
||||
@export var rival_line_offsets: PackedFloat32Array = PackedFloat32Array([-2.6, -1.8, 1.8, 2.6, -3.2])
|
||||
@export var rival_line_offsets: PackedFloat32Array = PackedFloat32Array([-0.7, -0.35, 0.35, 0.7, -1.0])
|
||||
|
||||
@export var distraction_enabled_baseline := false
|
||||
@export var distraction_interval_min := 6.0
|
||||
|
|
|
|||
|
|
@ -25,17 +25,17 @@ var nerve := 0.0
|
|||
var is_steadying := false
|
||||
|
||||
var _player: CharacterBody3D
|
||||
var _course_z := -4.0
|
||||
var _course_min_x := -20.0
|
||||
var _panic_timer := 0.0
|
||||
var _has_steady_lock := false
|
||||
var _bar: ProgressBar
|
||||
|
||||
|
||||
## Verknüpft den Spieler und die Kurs-Grenze (z, ab der der Parcours
|
||||
## Verknüpft den Spieler und die Kurs-Grenze (x, ab der der Parcours
|
||||
## beginnt) und baut die HUD-Leiste.
|
||||
func setup(player: CharacterBody3D, course_z: float) -> void:
|
||||
func setup(player: CharacterBody3D, course_min_x: float) -> void:
|
||||
_player = player
|
||||
_course_z = course_z
|
||||
_course_min_x = course_min_x
|
||||
_build_hud()
|
||||
|
||||
|
||||
|
|
@ -59,7 +59,7 @@ func _physics_process(delta: float) -> void:
|
|||
if _player == null or DialogueSystem.is_dialogue_active:
|
||||
return
|
||||
_panic_timer = maxf(_panic_timer - delta, 0.0)
|
||||
var is_in_course: bool = _player.global_position.z < _course_z
|
||||
var is_in_course: bool = _player.global_position.x > _course_min_x or _player.global_position.y > 2.0
|
||||
if is_in_course and _player.global_position.y > 4.0 and _is_looking_down():
|
||||
_set_nerve(nerve + nerve_look_down_rate * delta)
|
||||
var wants_steady := Input.is_action_pressed("steady") and is_in_course and _panic_timer <= 0.0
|
||||
|
|
|
|||
|
|
@ -63,13 +63,17 @@ func _physics_process(delta: float) -> void:
|
|||
_was_charging = is_charging
|
||||
|
||||
|
||||
## Klammert den Spieler an die Kugel, wenn er frei in die Greif-Zone kommt.
|
||||
## Klammert den Spieler an die Kugel, wenn er frei in die Greif-Zone
|
||||
## kommt; der Abstands-Check fängt veraltete Zonen-Events der pendelnden
|
||||
## Kugel ab (z. B. nach einem Respawn quer über die Terrasse).
|
||||
func _on_grab(body: Node3D) -> void:
|
||||
if _is_holding or not body.is_in_group("player"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
if to_local(player.global_position).distance_to(_ball.position) > 3.0:
|
||||
return
|
||||
_is_holding = true
|
||||
_charge = 0.0
|
||||
_was_charging = false
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ func _physics_process(delta: float) -> void:
|
|||
return
|
||||
var is_on_log := _is_player_on_log(player)
|
||||
if is_on_log and is_player_free(player):
|
||||
player.external_push = Vector3(0, 0, roll_speed * float(roll_dir))
|
||||
player.external_push = global_transform.basis.z * roll_speed * float(roll_dir)
|
||||
_was_on_log = true
|
||||
elif _was_on_log:
|
||||
player.external_push = Vector3.ZERO
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ func _physics_process(delta: float) -> void:
|
|||
var drift := cos(_time * shake_frequency * TAU) * shake_amplitude * shake_frequency * TAU * 0.35
|
||||
if nerve != null:
|
||||
drift *= nerve.drift_factor()
|
||||
player.external_push = Vector3(drift, 0.0, 0.0)
|
||||
player.external_push = global_transform.basis.x * drift
|
||||
_was_on_pillar = true
|
||||
elif _was_on_pillar:
|
||||
player.external_push = Vector3.ZERO
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ func _physics_process(delta: float) -> void:
|
|||
var drift := log_spin_speed * log_radius
|
||||
if nerve != null:
|
||||
drift *= nerve.drift_factor()
|
||||
player.external_push = Vector3(drift, 0.0, 0.0)
|
||||
player.external_push = global_transform.basis.x * drift
|
||||
_was_on_log = true
|
||||
elif _was_on_log:
|
||||
player.external_push = Vector3.ZERO
|
||||
|
|
|
|||
|
|
@ -1,109 +1,205 @@
|
|||
extends GauntletObstacle
|
||||
## Spinning Wheel (CR-002, ascent_1): großes, konstant drehendes Rad.
|
||||
## Spinning Wheel als geschlossene Trommel (CR-003 §3b).
|
||||
##
|
||||
## Der Spieler springt unten in die Einstiegs-Zone, wird auf der Kreisbahn
|
||||
## (y/z-Ebene) mitgedreht und muss den Ausstieg oben timen: Sprung-Taste
|
||||
## im Fenster wheel_exit_window um den Scheitel drückt ihn auf die
|
||||
## Ausstiegs-Plattform, ein Sprung außerhalb des Fensters wirft ihn ab
|
||||
## (player_fell). Ohne Tastendruck dreht das Rad einfach weiter — die
|
||||
## nächste Umdrehung ist die nächste Chance. Zwei Dummy-Kadetten drehen
|
||||
## als Timing-Referenz sichtbar mit.
|
||||
## Die Trommel steht mit der Radebene parallel zur Felswand (Achse zeigt
|
||||
## in die Wand); die äußere Haut ist durchgehend bis auf genau eine Lücke
|
||||
## (wheel_gap_arc). Ablauf: (1) seitlich durch die Lücke einspringen,
|
||||
## wenn sie an der Einstiegsseite vorbeikommt (wheel_entry_window),
|
||||
## (2) innen auf der Trommel-Innenfläche mitlaufen — die Drehung trägt
|
||||
## den Läufer sonst die Wand hoch (wheel_carry_force, A/D hält dagegen),
|
||||
## (3) wandert die Lücke unter den Füßen durch, rechtzeitig darüber
|
||||
## springen (gap_jump_window), sonst fällt er durch die Trommel,
|
||||
## (4) an der gegenüberliegenden Seite im Fenster wheel_exit_window durch
|
||||
## die Lücke hinausspringen. Zwei Dummy-Kadetten laufen sichtbar mit
|
||||
## (Timing-Referenz). Ein vertimter Einsprung prallt an der Haut ab
|
||||
## (Rückstoß, kein Tod); Fehler INNEN sind Stürze (player_fell).
|
||||
|
||||
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_exit_window := 0.45
|
||||
@export var exit_platform_offset := Vector3(0, -0.3, -2.0)
|
||||
@export var wheel_dir := 1
|
||||
@export var wheel_gap_arc := 1.0
|
||||
@export var wheel_entry_window := 0.6
|
||||
@export var gap_jump_window := 0.6
|
||||
@export var wheel_exit_window := 0.5
|
||||
@export var wheel_carry_force := 0.35
|
||||
@export var carry_limit := 0.9
|
||||
|
||||
var _pivot: Node3D
|
||||
var _dummy1: MeshInstance3D
|
||||
var _dummy2: MeshInstance3D
|
||||
var _is_riding := false
|
||||
var _ride_angle := 0.0
|
||||
var _is_in_entry_zone := false
|
||||
var _player_angle := 0.0
|
||||
var _hop_timer := 0.0
|
||||
var _has_cleared_pass := false
|
||||
var _time := 0.0
|
||||
|
||||
|
||||
## Baut Rad-Visual (Speichen + Kranz-Segmente), Dummy-Kadetten,
|
||||
## Einstiegs-Zone und Ausstiegs-Plattform.
|
||||
## Baut Haut-Segmente (mit Lücke), Nabe, Dummy-Kadetten, Einstiegs-Zone
|
||||
## und Ausstiegs-Plattform.
|
||||
func _ready() -> void:
|
||||
super()
|
||||
var radius := wheel_diameter / 2.0
|
||||
_pivot = Node3D.new()
|
||||
add_child(_pivot)
|
||||
for i in 8:
|
||||
var angle := TAU * float(i) / 8.0
|
||||
var segment := build_box_mesh(Vector3(0.5, 0.25, 1.7), Vector3(0, sin(angle) * radius, cos(angle) * radius), Color(0.5, 0.4, 0.3))
|
||||
segment.rotation.x = -angle
|
||||
var gap_half := wheel_gap_arc / 2.0
|
||||
var segment_count := 14
|
||||
var arc := TAU - wheel_gap_arc
|
||||
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.12, 0.3, 1.7), Vector3(sin(angle) * radius, -cos(angle) * radius, 0), Color(0.5, 0.4, 0.3))
|
||||
segment.rotation.z = angle
|
||||
_pivot.add_child(segment)
|
||||
for i in 2:
|
||||
var cadet := build_box_mesh(Vector3(0.5, 1.4, 0.5), Vector3.ZERO, Color(0.35, 0.35, 0.5))
|
||||
cadet.name = "DummyCadet%d" % (i + 1)
|
||||
_pivot.add_child(cadet)
|
||||
var entry := build_area(self, Vector3(2.0, 1.6, 1.6), Vector3(0, -radius + 0.6, 1.2))
|
||||
entry.body_entered.connect(_on_entry)
|
||||
var platform := build_box(self, Vector3(1.8, 0.4, 1.8), Vector3(exit_platform_offset.x, radius + exit_platform_offset.y, exit_platform_offset.z), Color(0.55, 0.54, 0.52))
|
||||
platform.name = "ExitPlatform"
|
||||
add_child(build_box_mesh(Vector3(0.5, 0.5, 2.0), Vector3.ZERO, Color(0.35, 0.3, 0.25)))
|
||||
_dummy1 = build_box_mesh(Vector3(0.45, 1.3, 0.45), Vector3.ZERO, Color(0.35, 0.35, 0.5))
|
||||
add_child(_dummy1)
|
||||
_dummy2 = build_box_mesh(Vector3(0.45, 1.3, 0.45), Vector3.ZERO, Color(0.3, 0.4, 0.45))
|
||||
add_child(_dummy2)
|
||||
var entry := build_area(self, Vector3(1.8, 2.0, 2.0), Vector3(-radius - 1.0, -radius + 1.0, 0))
|
||||
entry.body_entered.connect(_on_entry_zone_entered)
|
||||
entry.body_exited.connect(_on_entry_zone_exited)
|
||||
build_box(self, Vector3(1.8, 0.5, 1.8), Vector3(radius + 1.4, -radius + 0.25, 0), Color(0.55, 0.54, 0.52))
|
||||
|
||||
|
||||
## Dreht Rad und Dummy-Kadetten; während der Fahrt wird der Spieler auf
|
||||
## der Kreisbahn geführt und der Ausstieg abgefragt.
|
||||
## Merkt, dass der Spieler in der Einstiegs-Zone steht.
|
||||
func _on_entry_zone_entered(body: Node3D) -> void:
|
||||
if body.is_in_group("player"):
|
||||
_is_in_entry_zone = true
|
||||
|
||||
|
||||
## Merkt, dass der Spieler die Einstiegs-Zone verlassen hat.
|
||||
func _on_entry_zone_exited(body: Node3D) -> void:
|
||||
if body.is_in_group("player"):
|
||||
_is_in_entry_zone = false
|
||||
if not _is_riding:
|
||||
hide_prompt()
|
||||
|
||||
|
||||
## Dreht die Trommel, positioniert Dummy-Kadetten und treibt Einstieg,
|
||||
## Mitlaufen, Lücken-Sprung und Ausstieg an.
|
||||
func _physics_process(delta: float) -> void:
|
||||
_pivot.rotate_x(-wheel_speed * delta)
|
||||
_time += delta
|
||||
_pivot.rotate_z(wheel_speed * float(wheel_dir) * delta)
|
||||
var radius := wheel_diameter / 2.0
|
||||
_pivot.get_node("DummyCadet1").position = Vector3(0.8, sin(_ride_angle + 2.1) * (radius - 0.9), cos(_ride_angle + 2.1) * (radius - 0.9))
|
||||
_pivot.get_node("DummyCadet2").position = Vector3(-0.8, sin(_ride_angle + 4.2) * (radius - 0.9), cos(_ride_angle + 4.2) * (radius - 0.9))
|
||||
if not _is_riding:
|
||||
return
|
||||
_ride_angle += wheel_speed * delta
|
||||
var inner := radius - 0.55
|
||||
_dummy1.position = Vector3(sin(0.55 + sin(_time * 2.0) * 0.08) * inner, -cos(0.55) * inner + 0.65, 0.4)
|
||||
_dummy2.position = Vector3(sin(-0.5 + sin(_time * 1.7) * 0.08) * inner, -cos(-0.5) * inner + 0.65, -0.4)
|
||||
var player := get_player()
|
||||
if player == null:
|
||||
return
|
||||
player.velocity = Vector3.ZERO
|
||||
player.global_position = to_global(Vector3(0, -cos(_ride_angle) * (radius - 1.0), sin(_ride_angle) * (radius - 1.0)))
|
||||
var is_in_window := _is_in_exit_window()
|
||||
if is_in_window:
|
||||
show_prompt("JETZT ABSPRINGEN! — Leertaste / A-Taste")
|
||||
if _is_riding:
|
||||
_process_ride(player, delta, inner)
|
||||
else:
|
||||
show_prompt("Ausstieg oben timen — Leertaste / A-Taste im Fenster")
|
||||
if Input.is_action_just_pressed("jump"):
|
||||
if is_in_window:
|
||||
_finish_ride(true)
|
||||
_process_entry(player)
|
||||
|
||||
|
||||
## Einstieg: In der Zone warten, bis die Lücke links vorbeikommt, dann
|
||||
## Leertaste; vertimter Sprung prallt an der Haut ab.
|
||||
func _process_entry(player: CharacterBody3D) -> void:
|
||||
if not _is_in_entry_zone or not is_player_free(player):
|
||||
return
|
||||
var is_gap_at_entry := _angle_distance(_gap_angle(), -PI / 2.0) < _window_tolerance(wheel_entry_window)
|
||||
if is_gap_at_entry:
|
||||
show_prompt("JETZT: durch die Lücke! — Leertaste / A-Taste")
|
||||
else:
|
||||
show_prompt("Warten, bis die Lücke links ist — Leertaste / A-Taste")
|
||||
if not Input.is_action_just_pressed("jump"):
|
||||
return
|
||||
hide_prompt()
|
||||
if is_gap_at_entry:
|
||||
_is_riding = true
|
||||
_player_angle = 0.0
|
||||
_hop_timer = 0.0
|
||||
_has_cleared_pass = false
|
||||
player.set_control_locked(true)
|
||||
wheel_entered.emit()
|
||||
else:
|
||||
player.velocity = global_transform.basis.x * -3.0 + Vector3(0, 2.0, 0)
|
||||
|
||||
|
||||
## Fahrt in der Trommel: Mitlaufen gegen die Drehung, Lücke überspringen,
|
||||
## Ausstieg an der Gegenseite timen.
|
||||
func _process_ride(player: CharacterBody3D, delta: float, inner: float) -> void:
|
||||
_hop_timer = maxf(_hop_timer - delta, 0.0)
|
||||
_player_angle += wheel_speed * float(wheel_dir) * wheel_carry_force * delta
|
||||
_player_angle += Input.get_axis("move_left", "move_right") * 1.1 * delta
|
||||
player.velocity = Vector3.ZERO
|
||||
player.global_position = to_global(Vector3(sin(_player_angle) * inner, -cos(_player_angle) * inner, 0))
|
||||
if absf(_player_angle) > carry_limit:
|
||||
_fail_ride(player, Vector3(0, 2.0, 0))
|
||||
return
|
||||
var gap := _gap_angle()
|
||||
var gap_half := wheel_gap_arc / 2.0
|
||||
var is_gap_under := _angle_distance(gap, _player_angle) < gap_half * 0.7
|
||||
var is_exit_window := _angle_distance(gap, PI / 2.0) < _window_tolerance(wheel_exit_window)
|
||||
if is_gap_under:
|
||||
if _hop_timer > 0.0 or _has_cleared_pass:
|
||||
if not _has_cleared_pass:
|
||||
_has_cleared_pass = true
|
||||
wheel_gap_cleared.emit()
|
||||
else:
|
||||
_finish_ride(false)
|
||||
player.global_position = to_global(Vector3(sin(_player_angle) * (inner + 0.8), -cos(_player_angle) * (inner + 0.8), 0))
|
||||
_fail_ride(player, Vector3(0, -6.5, 0))
|
||||
return
|
||||
else:
|
||||
_has_cleared_pass = false
|
||||
if is_exit_window:
|
||||
show_prompt("AUSSTIEG rechts: durch die Lücke! — Leertaste / A-Taste")
|
||||
elif _angle_distance(gap, _player_angle) < gap_half + 0.6:
|
||||
show_prompt("Die Lücke kommt: DRÜBERSPRINGEN — Leertaste / A-Taste")
|
||||
else:
|
||||
show_prompt("Mitlaufen: A/D bzw. Stick gegen die Drehung")
|
||||
if Input.is_action_just_pressed("jump"):
|
||||
if is_exit_window:
|
||||
_finish_ride(player)
|
||||
else:
|
||||
_hop_timer = gap_jump_window
|
||||
|
||||
|
||||
## Startet die Fahrt, wenn der Spieler frei in die Einstiegs-Zone springt.
|
||||
func _on_entry(body: Node3D) -> void:
|
||||
if _is_riding or not body.is_in_group("player"):
|
||||
return
|
||||
var player := body as CharacterBody3D
|
||||
if not is_player_free(player):
|
||||
return
|
||||
_is_riding = true
|
||||
_ride_angle = 0.2
|
||||
player.set_control_locked(true)
|
||||
|
||||
|
||||
## Beendet die Fahrt: Erfolg setzt auf die Ausstiegs-Plattform, ein
|
||||
## vertimter Absprung wirft den Spieler ab.
|
||||
func _finish_ride(is_success: bool) -> void:
|
||||
## Erfolgreicher Ausstieg durch die Lücke auf die Plattform dahinter.
|
||||
func _finish_ride(player: CharacterBody3D) -> void:
|
||||
_is_riding = false
|
||||
hide_prompt()
|
||||
var player := get_player()
|
||||
player.set_control_locked(false)
|
||||
if is_success:
|
||||
var radius := wheel_diameter / 2.0
|
||||
player.global_position = to_global(Vector3(exit_platform_offset.x, radius + exit_platform_offset.y + 0.4, exit_platform_offset.z))
|
||||
player.velocity = Vector3.ZERO
|
||||
mark_cleared()
|
||||
else:
|
||||
player.velocity = Vector3(2.0, 1.0, 0.0)
|
||||
report_fall()
|
||||
var radius := wheel_diameter / 2.0
|
||||
player.global_position = to_global(Vector3(radius + 1.4, -radius + 1.0, 0))
|
||||
player.velocity = Vector3.ZERO
|
||||
wheel_exited.emit()
|
||||
mark_cleared()
|
||||
|
||||
|
||||
## Prüft, ob die Fahrt gerade im Ausstiegs-Fenster um den Rad-Scheitel ist.
|
||||
func _is_in_exit_window() -> bool:
|
||||
var apex_phase := fposmod(_ride_angle, TAU)
|
||||
var window_half := wheel_speed * wheel_exit_window / 2.0
|
||||
return absf(apex_phase - PI) < maxf(window_half, 0.12)
|
||||
## Sturz in der Trommel (mitgerissen oder durch die Lücke gefallen).
|
||||
func _fail_ride(player: CharacterBody3D, exit_velocity: Vector3) -> void:
|
||||
_is_riding = false
|
||||
hide_prompt()
|
||||
player.set_control_locked(false)
|
||||
player.velocity = exit_velocity
|
||||
report_fall()
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade im Rad mitfährt (für Tests).
|
||||
## Aktuelle Welt-Winkelposition der Lücke (0 = unten, +pi/2 = rechts).
|
||||
func _gap_angle() -> float:
|
||||
return wrapf(_pivot.rotation.z, -PI, PI)
|
||||
|
||||
|
||||
## Toleranz eines Zeitfensters als Winkel (skaliert mit der Drehung und
|
||||
## dem manipulated-Fenster des Modus).
|
||||
func _window_tolerance(window: float) -> float:
|
||||
var scaled := window
|
||||
if mode != null:
|
||||
scaled *= mode.window_scale()
|
||||
return maxf(wheel_gap_arc * 0.4 + wheel_speed * scaled * 0.5, 0.2)
|
||||
|
||||
|
||||
## Kleinste Winkeldistanz zweier Winkel.
|
||||
func _angle_distance(a: float, b: float) -> float:
|
||||
return absf(wrapf(a - b, -PI, PI))
|
||||
|
||||
|
||||
## Meldet, ob der Spieler gerade in der Trommel mitfährt (für Tests).
|
||||
func is_riding() -> bool:
|
||||
return _is_riding
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ func _physics_process(_delta: float) -> void:
|
|||
if is_on_ramp and is_player_free(player):
|
||||
var speed := Vector3(player.velocity.x, 0, player.velocity.z).length()
|
||||
if speed < ramp_min_momentum:
|
||||
player.external_push = Vector3(0, 0, slide_back_push)
|
||||
player.external_push = global_transform.basis.z * slide_back_push
|
||||
else:
|
||||
player.external_push = Vector3.ZERO
|
||||
_was_on_ramp = true
|
||||
|
|
|
|||
|
|
@ -1,25 +1,27 @@
|
|||
extends Node3D
|
||||
## Rival-Kadetten des Ernstlaufs (CR-002 §7) — rein ambient.
|
||||
## Rival-Kadetten des Ernstlaufs (CR-002 §7, Serpentine per CR-003) —
|
||||
## rein ambient.
|
||||
##
|
||||
## Nur im exam-Modus: rival_count Kadetten-Silhouetten klettern auf
|
||||
## versetzten Linien (rival_line_offsets) die Kurs-Linie hinauf, ohne
|
||||
## Kollision mit Tyrveil. Sichtbare Tode: Der Zeitplan
|
||||
## rival_fall_schedule lässt Kadetten nacheinander abstürzen (Fall-Tween
|
||||
## in den Nebel + Verschwinden); als Kanon-Anker stirbt der erste Kadett,
|
||||
## der die Rolling-Logs-Zone erreicht, dort IMMER (Quetschung). Im
|
||||
## manipulated-Preset läuft der Zeitplan gerafft. Jeder Sturz speist über
|
||||
## rival_fell das Nerven-System.
|
||||
## Nur im exam-Modus: rival_count Kadetten-Silhouetten laufen die
|
||||
## Terrassen-Serpentine auf quer versetzten Linien (rival_line_offsets,
|
||||
## seitlich zur Laufrichtung) ab, ohne Kollision mit Tyrveil. Sichtbare
|
||||
## Tode: Der Zeitplan rival_fall_schedule lässt Kadetten nacheinander
|
||||
## abstürzen (Fall-Tween in den Nebel + Verschwinden); als Kanon-Anker
|
||||
## stirbt der erste Kadett, der das Höhenband der Rolling Logs erreicht,
|
||||
## dort IMMER (Quetschung). Im manipulated-Preset läuft der Zeitplan
|
||||
## gerafft. Jeder Sturz speist über rival_fell das Nerven-System —
|
||||
## Sichtlinie darauf bieten besonders die Kurven.
|
||||
|
||||
signal rival_fell(rival_id: int, ascent_index: int)
|
||||
signal rival_fell(rival_id: int, terrace_index: int)
|
||||
|
||||
@export var rival_count := 5
|
||||
@export var rival_climb_speed := 1.6
|
||||
@export var rival_fall_schedule: PackedFloat32Array = PackedFloat32Array([18.0, 42.0])
|
||||
@export var rival_line_offsets: PackedFloat32Array = PackedFloat32Array([-2.6, -1.8, 1.8, 2.6, -3.2])
|
||||
@export var rival_line_offsets: PackedFloat32Array = PackedFloat32Array([-0.7, -0.35, 0.35, 0.7, -1.0])
|
||||
|
||||
var _spine: Array[Vector3] = []
|
||||
var _ascent_breaks: PackedFloat32Array = PackedFloat32Array()
|
||||
var _crush_zone := Vector2.ZERO
|
||||
var _terrace_breaks: PackedFloat32Array = PackedFloat32Array()
|
||||
var _crush_band := Vector2.ZERO
|
||||
var _rivals: Array[Node3D] = []
|
||||
var _distances: Array[float] = []
|
||||
var _is_active := false
|
||||
|
|
@ -29,19 +31,19 @@ var _has_crush_death := false
|
|||
var _spine_length := 0.0
|
||||
|
||||
|
||||
## Verknüpft Kurs-Linie, Ascent-Grenzen (z-Werte) und die
|
||||
## Rolling-Logs-Zone (z-Bereich) und spawnt die Kadetten.
|
||||
func setup(spine: Array[Vector3], ascent_breaks: PackedFloat32Array, crush_zone: Vector2, haste_scale: float) -> void:
|
||||
## Verknüpft Serpentinen-Linie, Terrassen-Grenzen (Höhen) und das
|
||||
## Quetsch-Höhenband der Rolling Logs und spawnt die Kadetten.
|
||||
func setup(spine: Array[Vector3], terrace_breaks: PackedFloat32Array, crush_band: Vector2, haste_scale: float) -> void:
|
||||
_spine = spine
|
||||
_ascent_breaks = ascent_breaks
|
||||
_crush_zone = crush_zone
|
||||
_terrace_breaks = terrace_breaks
|
||||
_crush_band = crush_band
|
||||
for i in _spine.size() - 1:
|
||||
_spine_length += _spine[i].distance_to(_spine[i + 1])
|
||||
for i in rival_count:
|
||||
var rival := _make_rival(i)
|
||||
add_child(rival)
|
||||
_rivals.append(rival)
|
||||
_distances.append(-2.5 * float(i))
|
||||
_distances.append(-3.0 * float(i))
|
||||
if haste_scale != 1.0:
|
||||
for i in rival_fall_schedule.size():
|
||||
rival_fall_schedule[i] *= haste_scale
|
||||
|
|
@ -60,7 +62,7 @@ func stop() -> void:
|
|||
rival.visible = false
|
||||
|
||||
|
||||
## Anzahl noch kletternder Kadetten (für Tests/Overlay).
|
||||
## Anzahl noch laufender Kadetten (für Tests/Overlay).
|
||||
func alive_count() -> int:
|
||||
var count := 0
|
||||
for rival in _rivals:
|
||||
|
|
@ -69,8 +71,8 @@ func alive_count() -> int:
|
|||
return count
|
||||
|
||||
|
||||
## Bewegt die Kadetten die Linie hinauf und arbeitet den Sturz-Zeitplan
|
||||
## sowie den Kanon-Tod an den Rolling Logs ab.
|
||||
## Bewegt die Kadetten die Serpentine entlang und arbeitet den
|
||||
## Sturz-Zeitplan sowie den Kanon-Tod an den Rolling Logs ab.
|
||||
func _physics_process(delta: float) -> void:
|
||||
if not _is_active or DialogueSystem.is_dialogue_active:
|
||||
return
|
||||
|
|
@ -82,9 +84,9 @@ func _physics_process(delta: float) -> void:
|
|||
_distances[i] += rival_climb_speed * delta
|
||||
var travelled: float = clampf(_distances[i], 0.0, _spine_length)
|
||||
var point := _sample_spine(travelled)
|
||||
point.x += rival_line_offsets[i % rival_line_offsets.size()]
|
||||
point.z += rival_line_offsets[i % rival_line_offsets.size()]
|
||||
rival.global_position = point
|
||||
if not _has_crush_death and point.z <= _crush_zone.y and point.z >= _crush_zone.x:
|
||||
if not _has_crush_death and point.y >= _crush_band.x and point.y <= _crush_band.y:
|
||||
_has_crush_death = true
|
||||
_kill_rival(i)
|
||||
continue
|
||||
|
|
@ -95,7 +97,7 @@ func _physics_process(delta: float) -> void:
|
|||
|
||||
|
||||
## Lässt den nächsten planmäßigen Kadetten stürzen (sofern noch einer
|
||||
## klettert).
|
||||
## läuft).
|
||||
func _kill_scheduled() -> void:
|
||||
_next_fall += 1
|
||||
for i in _rivals.size():
|
||||
|
|
@ -108,22 +110,22 @@ func _kill_scheduled() -> void:
|
|||
## Signal an das Nerven-System.
|
||||
func _kill_rival(index: int) -> void:
|
||||
var rival := _rivals[index]
|
||||
var ascent := _ascent_at(rival.global_position.z)
|
||||
var terrace := _terrace_at(rival.global_position.y)
|
||||
var tween := create_tween()
|
||||
tween.tween_property(rival, "global_position:y", rival.global_position.y - 30.0, 1.2)
|
||||
tween.tween_callback(func() -> void: rival.visible = false)
|
||||
rival_fell.emit(index, ascent)
|
||||
rival_fell.emit(index, terrace)
|
||||
|
||||
|
||||
## Ordnet eine z-Position dem Ascent-Index 1..5 zu.
|
||||
func _ascent_at(z: float) -> int:
|
||||
for i in _ascent_breaks.size():
|
||||
if z > _ascent_breaks[i]:
|
||||
## Ordnet eine Höhe dem Terrassen-Index 1..5 zu.
|
||||
func _terrace_at(y: float) -> int:
|
||||
for i in _terrace_breaks.size():
|
||||
if y < _terrace_breaks[i]:
|
||||
return i + 1
|
||||
return _ascent_breaks.size() + 1
|
||||
return _terrace_breaks.size() + 1
|
||||
|
||||
|
||||
## Interpoliert einen Punkt in gegebener Distanz entlang der Kurs-Linie.
|
||||
## Interpoliert einen Punkt in gegebener Distanz entlang der Serpentine.
|
||||
func _sample_spine(travelled: float) -> Vector3:
|
||||
var remaining := travelled
|
||||
for i in _spine.size() - 1:
|
||||
|
|
|
|||
226
scripts/gameplay/safety_rope_field.gd
Normal file
226
scripts/gameplay/safety_rope_field.gd
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
extends Node3D
|
||||
## Seilfeld im Sturzkorridor (CR-003 §4) — ersetzt die Wand-Anker aus
|
||||
## CR-002.
|
||||
##
|
||||
## Die Seile hängen frei AUSSEN im Sturzkorridor vor der offenen
|
||||
## Terrassen-Seite, über die volle Wandhöhe, im Abstand rope_spacing.
|
||||
## Der Seilfang ist ein Fall-Feature: Stürzt Tyrveil nach außen, fällt
|
||||
## sie ins Seilfeld und bekommt ein Greif-Fenster (rope_catch_window,
|
||||
## Leertaste/A). Erfolg: Sie hängt frei am Seil, arbeitet sich in
|
||||
## rope_recover_time zurück auf den letzten sicheren Absatz und kassiert
|
||||
## rope_time_penalty. Fehlschlag: Sie fällt durch das Feld -> rope_missed
|
||||
## (Death-State). JEDE Seilberührung zählt: Auch wer im Lauf ein Seil
|
||||
## streift, kassiert die Strafe (rope_touched). Stürze, die auf der
|
||||
## No-Rope-Terrasse beginnen (Rolling Logs), gehen den Hang hinab und
|
||||
## erreichen das Feld nie -> kein Fang, sicher tödlich. Im Ernstlauf gibt
|
||||
## es kein Abklettern am Seil (Descent-Sperre im climb_controller).
|
||||
|
||||
signal rope_touched(time_penalty: float)
|
||||
signal rope_caught
|
||||
signal rope_missed
|
||||
|
||||
@export var rope_spacing := 1.8
|
||||
@export var rope_catch_window := 0.7
|
||||
@export var rope_recover_time := 1.2
|
||||
@export var rope_time_penalty := 30.0
|
||||
@export var corridor_z := 2.4
|
||||
@export var corridor_top := 32.0
|
||||
@export var touch_radius := 0.5
|
||||
@export var course_min_x := -20.0
|
||||
|
||||
var _player: CharacterBody3D
|
||||
var _mode: Node
|
||||
var _rope_xs: PackedFloat32Array = PackedFloat32Array()
|
||||
var _anchors: Array[Vector3] = []
|
||||
var _no_rope_bands: Array[Vector2] = []
|
||||
var _last_floor_y := 0.0
|
||||
var _is_catching := false
|
||||
var _touch_cooldown := 0.0
|
||||
var _label: Label
|
||||
|
||||
|
||||
## Verknüpft Spieler und Modus, hängt die Seile über den x-Bereich des
|
||||
## Kurses und merkt sichere Absätze sowie No-Rope-Bänder (Absturz-
|
||||
## Ursprungshöhen der Rolling-Logs-Terrasse).
|
||||
func setup(player: CharacterBody3D, gauntlet_mode: Node, x_min: float, x_max: float, anchors: Array[Vector3], no_rope_bands: Array[Vector2]) -> void:
|
||||
_player = player
|
||||
_mode = gauntlet_mode
|
||||
_anchors = anchors
|
||||
_no_rope_bands = no_rope_bands
|
||||
var x := x_min
|
||||
while x <= x_max:
|
||||
_rope_xs.append(x)
|
||||
add_child(_make_rope_visual(x))
|
||||
x += rope_spacing
|
||||
_build_ui()
|
||||
|
||||
|
||||
## Anzahl gespannter Seile (für Tests/Overlay).
|
||||
func rope_count() -> int:
|
||||
return _rope_xs.size()
|
||||
|
||||
|
||||
## Meldet, ob gerade ein Greif-Fenster oder die Hang-Phase läuft.
|
||||
func is_catching() -> bool:
|
||||
return _is_catching
|
||||
|
||||
|
||||
## Prüft, ob eine Absturz-Ursprungshöhe in einem No-Rope-Band liegt.
|
||||
func is_in_no_rope(origin_y: float) -> bool:
|
||||
for band in _no_rope_bands:
|
||||
if origin_y >= band.x and origin_y <= band.y:
|
||||
return true
|
||||
return false
|
||||
|
||||
|
||||
## Verfolgt die letzte sichere Standhöhe, erkennt freie Stürze und
|
||||
## Seil-Berührungen im Vorbeigehen.
|
||||
func _physics_process(delta: float) -> void:
|
||||
if _player == null or DialogueSystem.is_dialogue_active:
|
||||
return
|
||||
_touch_cooldown = maxf(_touch_cooldown - delta, 0.0)
|
||||
if _is_catching or _player.is_control_locked():
|
||||
return
|
||||
if _player.is_on_floor():
|
||||
_last_floor_y = _player.global_position.y
|
||||
if not _is_in_course():
|
||||
return
|
||||
_check_passing_touch()
|
||||
if _player.velocity.y < -6.0:
|
||||
attempt_catch()
|
||||
|
||||
|
||||
## Startet den Seilfang-Versuch: In No-Rope-Zonen gibt es keinen Fang
|
||||
## (rope_missed), sonst öffnet das Greif-Fenster im Fall.
|
||||
func attempt_catch() -> void:
|
||||
if _is_catching:
|
||||
return
|
||||
if is_in_no_rope(_last_floor_y):
|
||||
rope_missed.emit()
|
||||
return
|
||||
_is_catching = true
|
||||
_run_catch_qte()
|
||||
|
||||
|
||||
## Spielt Greif-Fenster und Hang-Phase als Coroutine: Der Fall friert
|
||||
## kurz ein, Leertaste/A greift; danach hängt Tyrveil rope_recover_time
|
||||
## am Seil und wird auf den letzten sicheren Absatz gesetzt. Der erste
|
||||
## Physik-Frame wird übersprungen, damit der Tastendruck, der den Sturz
|
||||
## auslöste, nicht sofort als Griff zählt.
|
||||
func _run_catch_qte() -> void:
|
||||
var frozen := _player.global_position
|
||||
_player.set_control_locked(true)
|
||||
_label.text = "SEIL GREIFEN! — Leertaste / A-Taste"
|
||||
_label.visible = true
|
||||
await get_tree().physics_frame
|
||||
var window := rope_catch_window
|
||||
if _mode != null:
|
||||
window *= _mode.window_scale()
|
||||
var start := Time.get_ticks_msec()
|
||||
var is_caught := false
|
||||
while float(Time.get_ticks_msec() - start) / 1000.0 < window:
|
||||
_player.velocity = Vector3.ZERO
|
||||
_player.global_position = frozen
|
||||
if Input.is_action_just_pressed("grab_rope"):
|
||||
is_caught = true
|
||||
break
|
||||
await get_tree().physics_frame
|
||||
if not is_caught:
|
||||
_label.visible = false
|
||||
_player.set_control_locked(false)
|
||||
_is_catching = false
|
||||
_player.velocity = Vector3(0, -6, 0)
|
||||
rope_missed.emit()
|
||||
return
|
||||
rope_caught.emit()
|
||||
rope_touched.emit(rope_time_penalty)
|
||||
var rope_x := _nearest_rope_x(frozen.x)
|
||||
var hang := Vector3(rope_x, maxf(frozen.y, 2.0), corridor_z - 0.5)
|
||||
_label.text = "Am Seil — zurückarbeiten …"
|
||||
var hang_start := Time.get_ticks_msec()
|
||||
while float(Time.get_ticks_msec() - hang_start) / 1000.0 < rope_recover_time:
|
||||
_player.velocity = Vector3.ZERO
|
||||
_player.global_position = hang
|
||||
await get_tree().physics_frame
|
||||
_label.visible = false
|
||||
_player.set_control_locked(false)
|
||||
_is_catching = false
|
||||
_land_at_anchor(hang)
|
||||
|
||||
|
||||
## Setzt Tyrveil nach der Hang-Phase auf den nächsten sicheren Absatz
|
||||
## unterhalb der Fangstelle.
|
||||
func _land_at_anchor(hang: Vector3) -> void:
|
||||
var best := _anchors[0]
|
||||
var best_distance := INF
|
||||
for anchor in _anchors:
|
||||
if anchor.y > hang.y + 1.5:
|
||||
continue
|
||||
var distance := anchor.distance_to(hang)
|
||||
if distance < best_distance:
|
||||
best_distance = distance
|
||||
best = anchor
|
||||
_player.global_position = best + Vector3(0, 0.2, 0)
|
||||
_player.velocity = Vector3.ZERO
|
||||
|
||||
|
||||
## Berührung im Vorbeigehen: Wer einem hängenden Seil zu nahe kommt,
|
||||
## kassiert die Zeitstrafe (mit Abkling-Sperre gegen Mehrfach-Zählung).
|
||||
func _check_passing_touch() -> void:
|
||||
if _touch_cooldown > 0.0:
|
||||
return
|
||||
var position := _player.global_position
|
||||
if absf(position.z - corridor_z) > touch_radius:
|
||||
return
|
||||
var rope_x := _nearest_rope_x(position.x)
|
||||
if absf(position.x - rope_x) > touch_radius:
|
||||
return
|
||||
_touch_cooldown = 3.0
|
||||
rope_touched.emit(rope_time_penalty)
|
||||
|
||||
|
||||
## Liefert die x-Position des nächstgelegenen Seils.
|
||||
func _nearest_rope_x(x: float) -> float:
|
||||
var best := _rope_xs[0]
|
||||
for rope_x in _rope_xs:
|
||||
if absf(rope_x - x) < absf(best - x):
|
||||
best = rope_x
|
||||
return best
|
||||
|
||||
|
||||
## Prüft, ob Tyrveil den Parcours betreten hat (jenseits des Fußes).
|
||||
func _is_in_course() -> bool:
|
||||
return _player.global_position.x > course_min_x or _player.global_position.y > 2.0
|
||||
|
||||
|
||||
## Baut das hängende Seil-Visual über die volle Wandhöhe.
|
||||
func _make_rope_visual(x: float) -> MeshInstance3D:
|
||||
var mesh_instance := MeshInstance3D.new()
|
||||
var mesh := BoxMesh.new()
|
||||
mesh.size = Vector3(0.07, corridor_top + 8.0, 0.07)
|
||||
var material := StandardMaterial3D.new()
|
||||
material.albedo_color = Color(0.85, 0.8, 0.6)
|
||||
mesh.material = material
|
||||
mesh_instance.mesh = mesh
|
||||
mesh_instance.position = Vector3(x, corridor_top / 2.0 - 4.0, corridor_z)
|
||||
return mesh_instance
|
||||
|
||||
|
||||
## Baut den Greif-Prompt (zentriert, versteckt).
|
||||
func _build_ui() -> void:
|
||||
var layer := CanvasLayer.new()
|
||||
layer.layer = 3
|
||||
var root := Control.new()
|
||||
root.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
root.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
_label = Label.new()
|
||||
_label.set_anchors_preset(Control.PRESET_CENTER)
|
||||
_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||||
_label.add_theme_font_size_override("font_size", 40)
|
||||
_label.add_theme_color_override("font_color", Color(0.95, 0.9, 0.5))
|
||||
_label.add_theme_color_override("font_outline_color", Color.BLACK)
|
||||
_label.add_theme_constant_override("outline_size", 8)
|
||||
_label.visible = false
|
||||
root.add_child(_label)
|
||||
layer.add_child(root)
|
||||
add_child(layer)
|
||||
|
|
@ -1,198 +0,0 @@
|
|||
extends Node3D
|
||||
## Sicherungsseile des Gauntlet (CR-002 §6).
|
||||
##
|
||||
## Verteilt Seil-Punkte alle rope_spacing (~6 Fuß) entlang der Kurs-Linie
|
||||
## an der Felswand. Stürzt Tyrveil (Fehlgriff-Signal eines Hindernisses,
|
||||
## leerer Griff oder freier Fall), prüft das System, ob ein Seil in
|
||||
## rope_catch_radius hängt und die Stelle keine No-Rope-Zone ist: Dann
|
||||
## öffnet ein kurzes Greif-Fenster (rope_catch_window, Leertaste/A-Taste).
|
||||
## Erfolg: Tyrveil hängt am Seil, wird auf den letzten sicheren Absatz
|
||||
## darunter gesetzt und kassiert rope_time_penalty auf den Zeitlauf.
|
||||
## Fehlschlag oder kein Seil: freier Fall in die KillZone (Death-State).
|
||||
## Im Ernstlauf gibt es kein Abklettern an den Seilen — die Descent-Sperre
|
||||
## liegt im climb_controller.
|
||||
|
||||
signal rope_caught(time_penalty: float)
|
||||
signal catch_failed
|
||||
|
||||
@export var rope_spacing := 1.8
|
||||
@export var rope_catch_radius := 3.5
|
||||
@export var rope_catch_window := 0.7
|
||||
@export var rope_time_penalty := 30.0
|
||||
|
||||
var _player: CharacterBody3D
|
||||
var _mode: Node
|
||||
var _rope_points: Array[Vector3] = []
|
||||
var _anchors: Array[Vector3] = []
|
||||
var _no_rope_ranges: Array[Vector2] = []
|
||||
var _course_z := -4.0
|
||||
var _is_catching := false
|
||||
var _label: Label
|
||||
|
||||
|
||||
## Verknüpft Spieler und Modus, erzeugt die Seil-Punkte entlang der
|
||||
## Kurs-Linie (spine) und merkt sichere Absätze sowie No-Rope-Zonen
|
||||
## (z-Bereiche).
|
||||
func setup(player: CharacterBody3D, gauntlet_mode: Node, spine: Array[Vector3], anchors: Array[Vector3], no_rope_ranges: Array[Vector2], course_z: float) -> void:
|
||||
_player = player
|
||||
_mode = gauntlet_mode
|
||||
_anchors = anchors
|
||||
_no_rope_ranges = no_rope_ranges
|
||||
_course_z = course_z
|
||||
_generate_ropes(spine)
|
||||
_build_ui()
|
||||
|
||||
|
||||
## Anzahl erzeugter Seil-Punkte (für Tests/Overlay).
|
||||
func rope_count() -> int:
|
||||
return _rope_points.size()
|
||||
|
||||
|
||||
## Prüft, ob eine z-Position in einer No-Rope-Zone liegt.
|
||||
func is_in_no_rope(z: float) -> bool:
|
||||
for zone in _no_rope_ranges:
|
||||
if z >= zone.x and z <= zone.y:
|
||||
return true
|
||||
return false
|
||||
|
||||
|
||||
## Passive Sturz-Erkennung: freier Fall im Parcours startet den
|
||||
## Seilfang-Versuch.
|
||||
func _physics_process(_delta: float) -> void:
|
||||
if _player == null or _is_catching or DialogueSystem.is_dialogue_active:
|
||||
return
|
||||
if _player.is_control_locked():
|
||||
return
|
||||
if _player.global_position.z > _course_z:
|
||||
return
|
||||
if _player.velocity.y < -6.0:
|
||||
attempt_catch()
|
||||
|
||||
|
||||
## Meldet, ob gerade ein Greif-Fenster läuft (für Tests).
|
||||
func is_catching() -> bool:
|
||||
return _is_catching
|
||||
|
||||
|
||||
## Startet den Seilfang-Versuch: Seil in Reichweite und erlaubt -> QTE,
|
||||
## sonst sofort catch_failed (kein Seilfang möglich -> Death-State).
|
||||
func attempt_catch() -> void:
|
||||
if _is_catching:
|
||||
return
|
||||
var rope := _nearest_rope(_player.global_position)
|
||||
if rope == Vector3.INF or is_in_no_rope(_player.global_position.z):
|
||||
catch_failed.emit()
|
||||
return
|
||||
_is_catching = true
|
||||
_run_catch_qte(rope)
|
||||
|
||||
|
||||
## Spielt das Greif-Fenster als Coroutine: Spieler friert kurz ein,
|
||||
## Leertaste/A greift das Seil. Der erste Physik-Frame wird übersprungen,
|
||||
## damit der Tastendruck, der den Sturz auslöste (z. B. vertimter
|
||||
## Rad-Absprung), nicht sofort als Seilgriff zählt.
|
||||
func _run_catch_qte(rope: Vector3) -> void:
|
||||
var frozen := _player.global_position
|
||||
_player.set_control_locked(true)
|
||||
_label.text = "SEIL GREIFEN! — Leertaste / A-Taste"
|
||||
_label.visible = true
|
||||
await get_tree().physics_frame
|
||||
var window := rope_catch_window
|
||||
if _mode != null:
|
||||
window *= _mode.window_scale()
|
||||
var start := Time.get_ticks_msec()
|
||||
var is_caught := false
|
||||
while float(Time.get_ticks_msec() - start) / 1000.0 < window:
|
||||
_player.velocity = Vector3.ZERO
|
||||
_player.global_position = frozen
|
||||
if Input.is_action_just_pressed("grab_rope"):
|
||||
is_caught = true
|
||||
break
|
||||
await get_tree().physics_frame
|
||||
_label.visible = false
|
||||
_player.set_control_locked(false)
|
||||
_is_catching = false
|
||||
if is_caught:
|
||||
_land_at_anchor(rope)
|
||||
rope_caught.emit(rope_time_penalty)
|
||||
else:
|
||||
_player.velocity = Vector3(0, -6, 0)
|
||||
catch_failed.emit()
|
||||
|
||||
|
||||
## Setzt Tyrveil nach dem Seilfang auf den nächsten sicheren Absatz
|
||||
## unterhalb des Seils (sie hangelt zurück auf die Route).
|
||||
func _land_at_anchor(rope: Vector3) -> void:
|
||||
var best := _anchors[0]
|
||||
var best_distance := INF
|
||||
for anchor in _anchors:
|
||||
if anchor.y > rope.y + 1.0:
|
||||
continue
|
||||
var distance := anchor.distance_to(rope)
|
||||
if distance < best_distance:
|
||||
best_distance = distance
|
||||
best = anchor
|
||||
_player.global_position = best + Vector3(0, 0.2, 0)
|
||||
_player.velocity = Vector3.ZERO
|
||||
|
||||
|
||||
## Sucht den nächsten Seil-Punkt im Fang-Radius (Vector3.INF = keiner).
|
||||
func _nearest_rope(from_position: Vector3) -> Vector3:
|
||||
var best := Vector3.INF
|
||||
var best_distance := rope_catch_radius
|
||||
for rope in _rope_points:
|
||||
var distance := from_position.distance_to(rope)
|
||||
if distance < best_distance:
|
||||
best_distance = distance
|
||||
best = rope
|
||||
return best
|
||||
|
||||
|
||||
## Erzeugt die Seil-Punkte entlang der Kurs-Linie (alle rope_spacing),
|
||||
## überspringt No-Rope-Zonen und hängt kleine Visuals an die Wandseite.
|
||||
func _generate_ropes(spine: Array[Vector3]) -> void:
|
||||
for i in spine.size() - 1:
|
||||
var from := spine[i]
|
||||
var to := spine[i + 1]
|
||||
var length := from.distance_to(to)
|
||||
var steps := int(length / rope_spacing)
|
||||
for step in steps:
|
||||
var point := from.lerp(to, float(step) / float(maxi(steps, 1)))
|
||||
if is_in_no_rope(point.z):
|
||||
continue
|
||||
point.x += 1.5
|
||||
_rope_points.append(point)
|
||||
add_child(_make_rope_visual(point))
|
||||
|
||||
|
||||
## Baut das kleine Seil-Visual (heller Strang an der Wand).
|
||||
func _make_rope_visual(point: Vector3) -> MeshInstance3D:
|
||||
var mesh_instance := MeshInstance3D.new()
|
||||
var mesh := BoxMesh.new()
|
||||
mesh.size = Vector3(0.08, 1.2, 0.08)
|
||||
var material := StandardMaterial3D.new()
|
||||
material.albedo_color = Color(0.85, 0.8, 0.6)
|
||||
mesh.material = material
|
||||
mesh_instance.mesh = mesh
|
||||
mesh_instance.position = point
|
||||
return mesh_instance
|
||||
|
||||
|
||||
## Baut den Greif-Prompt (zentriert, versteckt).
|
||||
func _build_ui() -> void:
|
||||
var layer := CanvasLayer.new()
|
||||
layer.layer = 3
|
||||
var root := Control.new()
|
||||
root.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
root.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
_label = Label.new()
|
||||
_label.set_anchors_preset(Control.PRESET_CENTER)
|
||||
_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||||
_label.add_theme_font_size_override("font_size", 40)
|
||||
_label.add_theme_color_override("font_color", Color(0.95, 0.9, 0.5))
|
||||
_label.add_theme_color_override("font_outline_color", Color.BLACK)
|
||||
_label.add_theme_constant_override("outline_size", 8)
|
||||
_label.visible = false
|
||||
root.add_child(_label)
|
||||
layer.add_child(root)
|
||||
add_child(layer)
|
||||
|
|
@ -1,28 +1,33 @@
|
|||
class_name AscentConfig
|
||||
class_name TerraceConfig
|
||||
extends Resource
|
||||
## Tuning eines einzelnen Gauntlet-Ascents (CR-002), daten-getrieben unter
|
||||
## data/gauntlet/ascent_N.tres.
|
||||
## Tuning einer einzelnen Gauntlet-Terrasse (CR-003), daten-getrieben
|
||||
## unter data/gauntlet/terrace_N.tres.
|
||||
##
|
||||
## Superset aller Hindernis-Tunables der fünf Ascents; jede Resource
|
||||
## befüllt nur die für ihren Ascent relevanten Felder. gauntlet.gd
|
||||
## verteilt die Werte beim Start an die Hindernis-Instanzen des Ascents.
|
||||
## Superset aller Hindernis-Tunables der fünf Terrassen; jede Resource
|
||||
## befüllt nur die für ihre Terrasse relevanten Felder. gauntlet.gd
|
||||
## verteilt die Werte beim Start an die Hindernis-Instanzen der Terrasse.
|
||||
|
||||
@export var ascent_index := 1
|
||||
@export var terrace_index := 1
|
||||
@export var focus := ""
|
||||
|
||||
@export var log_spin_speed := 2.0
|
||||
@export var pillar_gap := 1.1
|
||||
@export var pillar_count := 4
|
||||
@export var wheel_speed := 0.8
|
||||
@export var wheel_exit_window := 0.45
|
||||
|
||||
@export var wheel_diameter := 4.0
|
||||
@export var wheel_speed := 0.8
|
||||
@export var wheel_dir := 1
|
||||
@export var wheel_gap_arc := 1.0
|
||||
@export var wheel_entry_window := 0.6
|
||||
@export var gap_jump_window := 0.6
|
||||
@export var wheel_exit_window := 0.5
|
||||
@export var wheel_carry_force := 0.35
|
||||
|
||||
@export var buoy_count := 5
|
||||
@export var buoy_spacing := 2.6
|
||||
@export var buoy_swing_period := 2.4
|
||||
@export var launch_window := 0.5
|
||||
@export var momentum_charge_time := 0.9
|
||||
@export var momentum_reach_bonus := 1.5
|
||||
|
||||
@export var rail_count := 3
|
||||
@export var rail_height_step := 0.15
|
||||
Loading…
Add table
Add a link
Reference in a new issue