windgeschworen/scripts/gameplay/grey_cadet.gd
danny 7f8429abdc v1-Ausbau Phase 3: Die Grauen als Statisten mit gewichtetem Bark-System
- grey_cadet (scenes/npcs/): namenlose graue Kapsel-Statisten ohne
  Interaktion; Naehe (bark_radius 4,5 m) zeigt mit Zufalls-Chance eine
  Ueberkopf-Zeile aus gewichteten JSON-Pools (data/barks/ambient.json:
  10 Zeilen Akademie-Gefluester; schergen.json: 5 Drohzeilen inkl.
  Cassians Kanon-Zeile); Cooldown pro Statist + globaler Cooldown,
  Pause waehrend Dialogen
- grey_spawner im Hof: verteilt 5 Statisten zufaellig; ab Tag 4 spawnen
  2 Schergen (dunkle Toenung, Drohungs-Pool), einer rempelt Wren
  skript-getriggert an (hinlaufen, Versatz + Reaktions-Zeile, Drohzeile,
  zurueck zum Posten) - Reaktions-Wahl des Spielers folgt mit den
  Cassian-Dialogen in Phase 4
- Verifikation: Sonde 12/12 gruen (Pools, Spawn-Zahlen Tag 1/4,
  Naehe-Bark + Cooldown, Schergen-Toenung, Wren-Anrempeln mit Versatz);
  Boot-Check fehlerfrei; Phase-3-Block nach CHANGEREQUESTS_DONE

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 23:01:03 +02:00

171 lines
5.4 KiB
GDScript

extends StaticBody3D
## „Die Grauen" — namenlose Statisten-Kadetten mit Bark-System
## (v1-Ausbau Phase 3, SPEC §5.1/STORY §5).
##
## Graue Kapsel ohne Interaktion: Kommt der Spieler in bark_radius,
## zeigt der Statist mit etwas Zufall eine Überkopf-Zeile aus dem
## gewichteten Pool (data/barks/ambient.json) über seine Sprechblase —
## mit eigenem Cooldown pro Statist und einem geteilten globalen
## Cooldown, damit der Hof nicht plappert wie ein Marktplatz. Die
## Schergen-Variante (is_scherge, ab Tag 4 vom Spawner gesetzt) nutzt
## den Drohungs-Pool (schergen.json), ist dunkler getönt und kann per
## Skript ein gezieltes Wren-Anrempeln laufen: hingehen, anrempeln,
## Drohzeile, zurück zum Posten.
const AMBIENT_POOL_PATH := "res://data/barks/ambient.json"
const SCHERGEN_POOL_PATH := "res://data/barks/schergen.json"
const GLOBAL_BARK_GAP_MS := 4000
static var _pools: Dictionary = {}
static var _last_global_bark_ms := -GLOBAL_BARK_GAP_MS
@export var is_scherge := false
@export var bark_radius := 4.5
@export var bark_cooldown := 12.0
@export var bark_chance := 0.6
@export var walk_speed := 2.6
var _cooldown_left := 0.0
var _poll_left := 0.0
var _bump_target: Node3D
var _home_position := Vector3.ZERO
var _bump_state := BumpState.IDLE
var _has_bumped := false
enum BumpState { IDLE, APPROACHING, RETURNING }
@onready var _bubble: Node3D = $SpeechBubble
@onready var _mesh: MeshInstance3D = $MeshInstance3D
## Lädt die Bark-Pools einmalig, merkt den Posten und tönt Schergen ab.
func _ready() -> void:
_load_pool(AMBIENT_POOL_PATH)
_load_pool(SCHERGEN_POOL_PATH)
_home_position = global_position
if is_scherge:
apply_scherge_tint()
## Färbt die Kapsel dunkler (Schergen-Variante); vom Spawner nach dem
## Setzen von is_scherge aufgerufen.
func apply_scherge_tint() -> void:
var material := StandardMaterial3D.new()
material.albedo_color = Color(0.3, 0.28, 0.3)
_mesh.material_override = material
## Startet das gezielte Wren-Anrempeln (skript-getriggert, ab Tag 4).
func start_bump(target: Node3D) -> void:
if _bump_state != BumpState.IDLE or target == null:
return
_bump_target = target
_bump_state = BumpState.APPROACHING
## Meldet, ob das Anrempeln durchgeführt wurde (für Tests).
func has_bumped() -> bool:
return _has_bumped
## Meldet, ob gerade eine Bark-Zeile sichtbar ist (für Tests).
func is_barking() -> bool:
return _bubble.visible
## Treibt Bark-Polling und die Anrempel-Bewegung an.
func _physics_process(delta: float) -> void:
_cooldown_left = maxf(_cooldown_left - delta, 0.0)
if _bump_state != BumpState.IDLE:
_process_bump(delta)
return
_poll_left -= delta
if _poll_left > 0.0:
return
_poll_left = 0.8
_try_bark()
## Zeigt mit etwas Zufall eine gewichtete Pool-Zeile, wenn der Spieler
## nah ist und kein Cooldown greift.
func _try_bark() -> void:
if _cooldown_left > 0.0 or DialogueSystem.is_dialogue_active:
return
if Time.get_ticks_msec() - _last_global_bark_ms < GLOBAL_BARK_GAP_MS:
return
var player := get_tree().get_first_node_in_group("player") as Node3D
if player == null or global_position.distance_to(player.global_position) > bark_radius:
return
if randf() > bark_chance:
return
_speak_from_pool()
## Spricht eine gewichtete Zufalls-Zeile aus dem passenden Pool.
func _speak_from_pool() -> void:
var pool_path := SCHERGEN_POOL_PATH if is_scherge else AMBIENT_POOL_PATH
var barks: Array = _pools.get(pool_path, [])
if barks.is_empty():
return
_bubble.show_line(_pick_weighted(barks))
_cooldown_left = bark_cooldown
_last_global_bark_ms = Time.get_ticks_msec()
## Anrempel-Ablauf: zum Ziel laufen, anrempeln + Drohzeile, zurück.
func _process_bump(delta: float) -> void:
if _bump_state == BumpState.APPROACHING:
if _bump_target == null or not is_instance_valid(_bump_target):
_bump_state = BumpState.RETURNING
return
var target := _bump_target.global_position
global_position = global_position.move_toward(target, walk_speed * delta)
if global_position.distance_to(target) < 1.0:
_execute_bump()
else:
global_position = global_position.move_toward(_home_position, walk_speed * delta)
if global_position.distance_to(_home_position) < 0.2:
_bump_state = BumpState.IDLE
## Der eigentliche Rempler: Ziel versetzen, Drohzeile, Reaktion des Ziels.
func _execute_bump() -> void:
var shove := (_bump_target.global_position - global_position)
shove.y = 0.0
_bump_target.global_position += shove.normalized() * 0.5
_speak_from_pool()
var target_bubble := _bump_target.get_node_or_null("SpeechBubble")
if target_bubble != null:
target_bubble.show_line("Hey—! Schon gut. Schon gut.")
_has_bumped = true
_bump_state = BumpState.RETURNING
## Lädt einen Bark-Pool einmalig in den statischen Cache.
func _load_pool(path: String) -> void:
if _pools.has(path):
return
var file := FileAccess.open(path, FileAccess.READ)
if file == null:
push_error("Bark-Pool fehlt: %s" % path)
_pools[path] = []
return
var parsed: Variant = JSON.parse_string(file.get_as_text())
if parsed is Dictionary and parsed.get("barks") is Array:
_pools[path] = parsed["barks"]
else:
push_error("Bark-Pool unlesbar: %s" % path)
_pools[path] = []
## Zieht eine Zeile gewichtet aus dem Pool.
func _pick_weighted(barks: Array) -> String:
var total := 0.0
for bark in barks:
total += float(bark.get("weight", 1))
var roll := randf() * total
for bark in barks:
roll -= float(bark.get("weight", 1))
if roll <= 0.0:
return str(bark.get("text", ""))
return str(barks[0].get("text", ""))