extends Area3D ## Ein loses Heftblatt, das im Wind über den Hof treibt — und ausweicht, ## wenn man danach greift (CR 12, Flugverhalten überarbeitet in CR 21). ## ## Das Blatt reagiert auf den Spieler. Kommt er in flee_radius, reißt es ## eine Böe weg: Es beschleunigt vom Spieler fort, wirbelt hoch und ## wechselt die Richtung. Danach sackt es ab und treibt für einen Moment ## kraftlos — das ist das Fenster, in dem Slide, Sprint und Sprung ## zugreifen. Gefangen wird weiter allein durch Berührung, ohne Taste. ## ## **Jede Jagd bleibt einholbar** (harte Regel des Autors, CR 21). Drei ## Sicherungen greifen ineinander, alle in data/pages/loose_pages.json ## unter "flight" nachvollziehbar: ## 1. gust_speed liegt **unter** der Sprint-Geschwindigkeit des Spielers. ## Das Blatt kann rein rechnerisch nie davonlaufen. ## 2. Es ermüdet: Jede Böe ist um fatigue_per_gust schwächer als die ## vorige, und nach max_gusts gibt es auf und treibt nur noch. ## 3. Nach jeder Böe folgt das Sackenfenster — langsamer als die ## Grunddrift und tiefer, also sicher greifbar. Die Böen-Sperre deckt ## dieses Fenster **vollständig** ab (gust_seconds + settle_seconds + ## gust_cooldown), damit keine Böe mitten ins Sacken hineinreißt. ## ## Verlässt das Blatt den Wirkungsradius, setzt es sich auf der ## Gegenseite neu an. Beim Fangen meldet es sich per caught mit seinen ## Daten; die Auswertung macht der PageSpawner. signal caught(page: Dictionary) signal gust_started(remaining_gusts: int) enum FlightState { DRIFT, GUST, SETTLE } const DRIFT_SPEED_MIN := 2.2 const DRIFT_SPEED_MAX := 3.6 const BOB_AMPLITUDE := 0.35 const BOB_SPEED_MIN := 1.4 const BOB_SPEED_MAX := 2.6 const TUMBLE_SPEED := 2.0 const TUMBLE_GUST_SCALE := 3.5 const HEIGHT_MIN := 0.5 const HEIGHT_MAX := 2.3 const HEIGHT_CEILING := 3.2 const LATERAL_SPREAD := 0.7 const HEIGHT_EASE := 3.0 var _page: Dictionary = {} var _flight: Dictionary = {} var _drift := Vector3.FORWARD var _drift_speed := DRIFT_SPEED_MIN var _bob_speed := BOB_SPEED_MIN var _bob_phase := 0.0 var _base_height := 1.2 var _rest_height := 1.2 var _center := Vector3.ZERO var _radius := 20.0 var _is_caught := false var _state := FlightState.DRIFT var _state_timer := 0.0 var _cooldown := 0.0 var _gust_count := 0 var _player: Node3D @onready var _mesh: Node3D = $MeshInstance3D @onready var _bubble: SpeechBubble = $SpeechBubble ## Verbindet den Fang-Trigger und sucht den Spieler. func _ready() -> void: body_entered.connect(_on_body_entered) _player = get_tree().get_first_node_in_group("player") ## Richtet das Blatt ein: Daten, Flugwerte, Treibkreis und Flugbahn. func setup(page: Dictionary, center: Vector3, radius: float, flight: Dictionary = {}) -> void: _page = page _flight = flight _center = center _radius = radius _drift = Vector3(randf_range(-1.0, 1.0), 0.0, randf_range(-1.0, 1.0)).normalized() _drift_speed = randf_range(DRIFT_SPEED_MIN, DRIFT_SPEED_MAX) _bob_speed = randf_range(BOB_SPEED_MIN, BOB_SPEED_MAX) _bob_phase = randf_range(0.0, TAU) _rest_height = randf_range(HEIGHT_MIN, HEIGHT_MAX) _base_height = _rest_height global_position = _center + Vector3( randf_range(-_radius, _radius), _base_height, randf_range(-_radius, _radius) ) ## Die Daten des Blattes (für Spawner und Tests). func get_page() -> Dictionary: return _page ## Der aktuelle Flugzustand (für Sonden). func get_flight_state() -> int: return _state ## Wie viele Böen das Blatt noch hat, bevor es aufgibt (für Sonden). func remaining_gusts() -> int: return maxi(_tuning("max_gusts", 5) - _gust_count, 0) ## Die Geschwindigkeit, mit der das Blatt gerade treibt (für Sonden). func current_speed() -> float: match _state: FlightState.GUST: return _gust_speed() FlightState.SETTLE: return _drift_speed * float(_tuning("settle_speed_scale", 0.4)) return _drift_speed ## Treibt das Blatt, lässt es wippen und trudeln, prüft die Annäherung ## des Spielers und setzt es am Kreisrand neu an. func _process(delta: float) -> void: if _is_caught: return _cooldown = maxf(_cooldown - delta, 0.0) _advance_state(delta) _check_player() global_position += _drift * current_speed() * delta _bob_phase += _bob_speed * delta var target_height := _base_height + sin(_bob_phase) * BOB_AMPLITUDE global_position.y = move_toward(global_position.y, target_height, HEIGHT_EASE * delta) var tumble := TUMBLE_SPEED if _state == FlightState.GUST: tumble *= TUMBLE_GUST_SCALE _mesh.rotate_y(tumble * delta) _mesh.rotation.x = sin(_bob_phase * 0.7) * 0.6 _wrap_into_circle() ## Zählt den laufenden Zustand herunter und schaltet weiter: Die Böe geht ## ins Sacken über, das Sacken zurück in die Grunddrift. func _advance_state(delta: float) -> void: if _state == FlightState.DRIFT: return _state_timer -= delta if _state_timer > 0.0: return if _state == FlightState.GUST: _state = FlightState.SETTLE _state_timer = float(_tuning("settle_seconds", 1.4)) _base_height = maxf(_rest_height - float(_tuning("settle_sink", 0.55)), HEIGHT_MIN * 0.5) return _state = FlightState.DRIFT _base_height = _rest_height ## Löst eine Böe aus, sobald der Spieler nah genug ist — sofern das Blatt ## nicht gerade flieht, in der Abklingzeit steckt oder schon aufgegeben hat. func _check_player() -> void: if _player == null or _state == FlightState.GUST: return if _cooldown > 0.0 or remaining_gusts() <= 0: return var away := global_position - _player.global_position away.y = 0.0 if away.length() > float(_tuning("flee_radius", 4.5)): return _start_gust(away) ## Startet die Böe: weg vom Spieler, mit seitlichem Ausschlag, hoch in ## die Luft — und schwächer als die Böe davor. func _start_gust(away: Vector3) -> void: if away.length_squared() < 0.01: away = Vector3(randf_range(-1.0, 1.0), 0.0, randf_range(-1.0, 1.0)) var lateral := Vector3(-away.z, 0.0, away.x).normalized() * randf_range(-LATERAL_SPREAD, LATERAL_SPREAD) _drift = (away.normalized() + lateral).normalized() _gust_count += 1 _state = FlightState.GUST _state_timer = float(_tuning("gust_seconds", 1.0)) _cooldown = _state_timer + float(_tuning("settle_seconds", 1.4)) + float(_tuning("gust_cooldown", 1.6)) _base_height = minf(_rest_height + float(_tuning("gust_rise", 1.3)), HEIGHT_CEILING) gust_started.emit(remaining_gusts()) ## Die Geschwindigkeit der laufenden Böe — jede ist um fatigue_per_gust ## schwächer als die vorige und nie schneller als der Startwert. func _gust_speed() -> float: var fatigue := 1.0 - float(_tuning("fatigue_per_gust", 0.18)) * float(_gust_count - 1) return maxf(float(_tuning("gust_speed", 6.0)) * maxf(fatigue, 0.25), _drift_speed) ## Setzt das Blatt am gegenüberliegenden Rand neu an, wenn es den ## Treibkreis verlässt. func _wrap_into_circle() -> void: var offset := global_position - _center offset.y = 0.0 if offset.length() <= _radius: return var wrapped := _center - offset.normalized() * _radius global_position = Vector3(wrapped.x, global_position.y, wrapped.z) ## Liest einen Flugwert aus den Daten, mit Rückfall auf den Standard. func _tuning(key: String, fallback: Variant) -> Variant: return _flight.get(key, fallback) ## Fängt das Blatt, sobald der Spieler es berührt: Mesh weg, Fundzeile ## einblenden, melden und nach der Zeile verschwinden. func _on_body_entered(body: Node3D) -> void: if _is_caught or not body.is_in_group("player"): return _is_caught = true _mesh.visible = false monitoring = false caught.emit(_page) var line := str(_page.get("catch_line", "")) if line.is_empty(): queue_free() return _bubble.line_finished.connect(queue_free) _bubble.show_line(line)