446 lines
17 KiB
GDScript
446 lines
17 KiB
GDScript
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 (Presentation Day), 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")
|
||
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
|