windgeschworen/scripts/gameplay/gauntlet.gd
danny 5c5f65f455 Phase 10: Der Zirkel — Wahrheits-Discovery (CR 2)
- Fünf W1-Fragment-Quellen (w1_fragment_*): Gefechtskunde-Frage,
  Aushang am Hof (ab Tag 4), Wrens Einberufungsakte in der
  Geschichtsklasse (ab Tag 6, „Weissagung"-Haken), Cassians
  Angebots-Andeutung, Graue-Bark (Pool-Einträge können min_day +
  fragment_flag tragen, gesammelte Zeilen verschwinden aus dem Umlauf)
- Xaden als aktiver Zirkel-Anker: neuer Wander-NPC am Hof mit
  Dialog-Stufen (Kennenlernen, Sammel-Auftrag, Muster-Bestätigung ab
  3 Fragmenten mit zirkel_bestaetigt + Gezeichneten-Standing +5,
  Zirkel-Wache, Trauer nach dem Wendepunkt)
- Zirkel-Fortschritt 0–100 (Fragmente ×12, Bestätigung +20, Wahrheit 2
  +20) als neuer Daumen in die Bindungsqualität (max +10);
  Muster-Board zeigt Fortschritt und Bestätigung
- Kein Gauntlet-Gate: apply_w1_gauntlet_outcome() belohnt ab 3
  Fragmenten mit Bestätigung + Fraktions-Bonus, sonst bleibt der
  Wendepunkt selbst die Enthüllung
- Buchführung: CR 2 nach CHANGEREQUESTS_DONE, Phasen-Plan auf Phase 11

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-16 18:08:42 +02:00

450 lines
17 KiB
GDScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

extends Node3D
## Ablauf-Steuerung des Gauntlet (CR-003: Serpentine über fünf Terrassen,
## Phase 4c: Wendepunkt, STORY.md Abschnitte 3 und 5).
##
## 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 Terrassen-5-Anfang: Intervention -> Einsturz, Wren
## gerettet, Maren getroffen -> Sterbeszene mit Wahrheit 1 und 2 ->
## 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 terrace_completed(index: int)
signal obstacle_cleared(obstacle_id: String)
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"
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 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_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(-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 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_terraces: Dictionary = {}
var _player: CharacterBody3D
var _dragons: Array[Node3D] = []
@onready var _maren: Node3D = $Maren
@onready var _wren: Node3D = $Wren
@onready var _mode: Node = $GauntletMode
@onready var _climb: Node = $ClimbController
@onready var _nerve: Node = $NerveSystem
@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, 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_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_touched.connect(_on_rope_touched)
_ropes.rope_missed.connect(_on_rope_missed)
_rivals.rival_fell.connect(_on_rival_fell)
_init_mode_and_story()
## Startet den Zeitlauf, sobald Tyrveil den Parcours im Ernstlauf betritt.
func _physics_process(_delta: float) -> void:
if _has_run_started or _player == null:
return
if not _mode.is_exam() or DialogueSystem.is_dialogue_active:
return
if _player.global_position.x > -19.5:
_has_run_started = true
_timer.start_run()
_rivals.start()
## Initialisiert Modus und Story: Der erste Besuch ist der manipulierte
## Ernstlauf (Tag der Präsentation), nach dem Wendepunkt freies Training.
func _init_mode_and_story() -> void:
if StorySystem.has_reached_beat("maren_death"):
_has_intervention_run = true
_mode.set_mode(_mode.Mode.TRAINING)
_mode.manipulated = false
_maren.queue_free()
_wren.queue_free()
$CollapsingSection.queue_free()
$InterventionTrigger.queue_free()
return
_mode.set_mode(_mode.Mode.EXAM)
_mode.manipulated = true
_apply_manipulated_preset()
var haste: float = _mode.rival_haste_scale()
_rivals.setup(SPINE, PackedFloat32Array(TERRACE_BREAKS), RIVAL_CRUSH_BAND, haste)
$InterventionTrigger.body_entered.connect(_on_intervention_entered)
_play_opening()
## Spielt den Auftakt-Dialog kurz nach dem Betreten.
func _play_opening() -> void:
StorySystem.advance_gauntlet_beat("gauntlet_started")
await get_tree().create_timer(0.8).timeout
if _player == null or DialogueSystem.is_dialogue_active:
return
DialogueSystem.start_dialogue(START_PATH, {
"maren": _maren,
"wren": _wren,
DialogueSystem.PLAYER_SPEAKER_ID: _player,
})
## 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 Terrassen-/Kurven-Szenen).
func _apply_tuning() -> void:
var tuning: GauntletTuning = load(TUNING_PATH)
_ropes.rope_spacing = tuning.rope_spacing
_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
_nerve.nerve_max = tuning.nerve_max
_nerve.nerve_on_rival_fall = tuning.nerve_on_rival_fall
_nerve.nerve_on_distraction = tuning.nerve_on_distraction
_nerve.nerve_look_down_rate = tuning.nerve_look_down_rate
_nerve.nerve_calm_rate = tuning.nerve_calm_rate
_nerve.nerve_decay_rate = tuning.nerve_decay_rate
_nerve.nerve_grip_penalty = tuning.nerve_grip_penalty
_nerve.nerve_panic_threshold = tuning.nerve_panic_threshold
_nerve.panic_lockout = tuning.panic_lockout
_rivals.rival_count = tuning.rival_count
_rivals.rival_climb_speed = tuning.rival_climb_speed
_rivals.rival_fall_schedule = tuning.rival_fall_schedule
_rivals.rival_line_offsets = tuning.rival_line_offsets
_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 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 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); 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 "launch_window" in obstacle:
obstacle.launch_window *= _mode.window_scale()
if "roll_speed" in obstacle:
obstacle.roll_speed *= _mode.roll_speed_scale()
## Verbindet Kontext und Signale aller Hindernisse.
func _wire_obstacles() -> void:
for obstacle in get_tree().get_nodes_in_group("gauntlet_obstacle"):
obstacle.setup_context(_nerve, _mode)
obstacle.cleared.connect(_on_obstacle_cleared)
obstacle.player_fell.connect(_on_obstacle_fall)
if obstacle.has_signal("crushed"):
obstacle.crushed.connect(_on_crushed)
## 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(-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)
add_child(_make_mesh(Vector3(56, 42, 1), Vector3(0, 17, -3.1), Color(0.36, 0.34, 0.33)))
## Baut eine begehbare Plattform (Fuß, Box-Canyon).
func _build_platform(center: Vector3, size: Vector3) -> void:
var body := StaticBody3D.new()
body.position = center
var shape := CollisionShape3D.new()
var box := BoxShape3D.new()
box.size = size
shape.shape = box
body.add_child(shape)
body.add_child(_make_mesh(size, Vector3.ZERO, Color(0.58, 0.55, 0.5)))
add_child(body)
## 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
area.position = center
area.add_to_group("gauntlet_rest")
var shape := CollisionShape3D.new()
var box := BoxShape3D.new()
box.size = size
shape.shape = box
area.add_child(shape)
if is_finish:
area.body_entered.connect(_on_finish_entered)
add_child(area)
## Baut ein reines Greybox-Mesh.
func _make_mesh(size: Vector3, position_offset: Vector3, color: Color) -> MeshInstance3D:
var mesh_instance := MeshInstance3D.new()
var mesh := BoxMesh.new()
mesh.size = size
var material := StandardMaterial3D.new()
material.albedo_color = color
mesh.material = material
mesh_instance.mesh = mesh
mesh_instance.position = position_offset
return mesh_instance
## Baut eine Drachen-Silhouette am Box-Canyon-Eingang.
func _make_dragon(spot: Vector3) -> Node3D:
var dragon := Node3D.new()
dragon.position = spot
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
## 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(36.3)
if _mode.is_training():
_checkpoint_position = TOP_CHECKPOINT
if _reached_terraces.has(5):
return
_reached_terraces[5] = true
terrace_completed.emit(5)
story_hook_reached.emit(5)
_timer.stop_run()
## Hindernis geschafft: Signal durchreichen.
func _on_obstacle_cleared(obstacle_id: String) -> void:
obstacle_cleared.emit(obstacle_id)
## Fehlgriff an einem Hindernis: Seilfang-Versuch im Sturz.
func _on_obstacle_fall(_source_id: String) -> void:
_ropes.attempt_catch()
## Griff leer oder Descent-Sperre gerissen: Seilfang-Versuch.
func _on_climber_fell() -> void:
_ropes.attempt_catch()
## 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)
## 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, _terrace_index: int) -> void:
_nerve.add_nerve(_nerve.nerve_on_rival_fall)
## Quetschung an den Rolling Logs: sicherer Tod, kein Seilfang.
func _on_crushed() -> void:
_handle_death()
## Sturz in den Abgrund (KillZone).
func _on_kill_zone_entered(body: Node3D) -> void:
if not body.is_in_group("player"):
return
_handle_death()
## Death-State: Game Over bei Permadeath AN; sonst Respawn am Checkpoint
## (Training) bzw. am Fuß mit neuem Zeitlauf (Ernstlauf) — betrifft nur
## Tyrveil, nie den Story-Beat.
func _handle_death() -> void:
if GameState.is_permadeath_enabled:
print("Game Over — der Gauntlet vergibt keine Fehler.")
Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
get_tree().change_scene_to_file.call_deferred(MAIN_MENU_SCENE)
return
_player.external_push = Vector3.ZERO
_player.velocity = Vector3.ZERO
_climb.reset_grip()
if _mode.is_exam():
_player.global_position = BASE_SPAWN
_timer.reset()
_has_run_started = false
else:
_player.global_position = _checkpoint_position
## 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
if _has_intervention_run or DialogueSystem.is_dialogue_active:
return
_has_intervention_run = true
_run_climax(body)
## Spielt den kompletten Wendepunkt als Coroutine: Intervention, Einsturz,
## Sterbeszene mit den Wahrheiten, Trauer-Entscheidung; danach ist der
## Lauf freies Training.
func _run_climax(player: CharacterBody3D) -> void:
StorySystem.advance_gauntlet_beat("maren_intervention")
_maren.global_position = MAREN_ARRIVAL_POSITION
DialogueSystem.start_dialogue(INTERVENTION_PATH, {
"maren": _maren,
"wren": _wren,
DialogueSystem.PLAYER_SPEAKER_ID: player,
})
await DialogueSystem.dialogue_finished
$CollapsingSection.queue_free()
_wren.global_position = WREN_SAFE_POSITION
_maren.global_position = MAREN_FALL_POSITION
_lay_maren_down()
StorySystem.advance_gauntlet_beat("maren_death")
DialogueSystem.start_dialogue(DEATH_PATH, {
"maren": _maren,
"wren": _wren,
DialogueSystem.PLAYER_SPEAKER_ID: player,
})
await DialogueSystem.dialogue_finished
StorySystem.advance_gauntlet_beat("truth_1_revealed")
StorySystem.advance_gauntlet_beat("truth_2_revealed")
if StorySystem.apply_w1_gauntlet_outcome():
var player_bubble: Node3D = player.get_node("SpeechBubble")
player_bubble.show_line("Du hast es kommen sehen — das Muster in deinem Lexicon. Maren hat es mit ihrem Leben bestätigt. Die Gezeichneten sehen dich anders an.")
await player_bubble.line_finished
DialogueSystem.start_dialogue(GRIEF_PATH, {
"wren": _wren,
DialogueSystem.PLAYER_SPEAKER_ID: player,
})
await DialogueSystem.dialogue_finished
StorySystem.advance_gauntlet_beat("gauntlet_completed")
_timer.stop_run()
_mode.manipulated = false
_mode.set_mode(_mode.Mode.TRAINING)
_rivals.stop()
_checkpoint_position = Vector3(-19, 25.3, -0.6)
## Legt Marens Mesh in Liegeposition; der Root bleibt aufrecht, damit
## Sprechblase und Namens-Label lesbar über ihr stehen.
func _lay_maren_down() -> void:
var mesh := _maren.get_node("MeshInstance3D") as Node3D
mesh.rotation.z = PI / 2.0
mesh.position.y = 0.4