Die Blaetter trieben bisher in konstanter Richtung und reagierten nicht auf den Spieler — ein bewegtes Pickup, keine Jagd. Jetzt hat das Blatt drei Flugzustaende: Treiben, Boee, Sacken. Kommt der Spieler nah, reisst eine Boee es weg — fort von ihm, mit seitlichem Ausschlag, schneller, hoeher und sichtbar heftiger trudelnd. Danach sackt es ab, tiefer und deutlich langsamer als die Grunddrift. Das ist das Fenster, in dem Slide, Sprint und Sprung zugreifen. Die Einholbarkeit ist konstruiert, nicht gehofft. gust_speed liegt unter der Sprint-Geschwindigkeit des Spielers, das Blatt ermuedet mit jeder Boee und gibt nach fuenf auf, und die Boeen-Sperre deckt das Sackenfenster vollstaendig ab. Alle Werte stehen im flight-Block von loose_pages.json, die Regel steht als balance_note daneben. Balance in zwei Schritten gefunden: die erste Fassung war zu zahm, die simulierte Jagd endete nach 1,4 s mit einer einzigen Boee. Beim Nachziehen fiel auf, dass die Abklingzeit mitten im Sacken ablief und das sichere Fenster auf 0,45 s zusammenschrumpfte — seitdem deckt die Sperre das ganze Fenster ab. Jetzt dauert die Jagd 7,4 Sekunden ueber drei Boeen und endet sicher. Fund-Typen, Gewichte, feste Schluessel-Seiten und alle Belohnungen aus CR 12 bleiben unveraendert. Verifiziert mit dev_cr21_probe (24/24), darunter eine simulierte Jagd, in der ein sprintender Verfolger das Blatt nachweislich einholt, und einem Boot-Check ueber acht Szenen; Sonde vor dem Commit geloescht. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
220 lines
7.5 KiB
GDScript
220 lines
7.5 KiB
GDScript
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)
|