DorfFall spielt die drei K3-Dateien in Segmenten mit dem Spiel dazwischen, Werte und Schnittknoten in data/story/dorf_fall.json: - Anflug ueber die Lieferstrecke, "Es steht noch" und der graue Ring noch in der Luft (DeadRing sichtbar), Landung bei "landung". - Gefecht ueber das bestehende Encounter-System, je ein Gegner an den drei VeneniSpawn-Markern, Smaladh in der Luft; sein "Ich weiss, was das ist" nach dem ersten Toten. - Nach der Entscheidung ein durchgehender Encounter samt Frau vom Brunnen, damit die Anzeigen nacheinander wegbrechen. Smaladh landet, wenn er aufhoert; waehrend der Erosion rueckt nach, bis sie durch ist, der Kopf dreht sich ohne Dialogbox nach Nordosten; bei die_pfuetze schwarze Augen. - Suche ueber die vier SearchPoints in beliebiger Reihenfolge, Stehenbleiben fuehrt ins naechste Haus; danach zweiter Durchgang oder Rueckfuehrung, Imogen steht hinter ihm in der Tuer, dann sie_kommt. Phasen weiter nur aus akt3_k3_fall.json. Runner: im_flug_bis (Dialog waehrend der Anreise), ablauf (Komponente je Ort), Folgeszenen am selben Ort setzen Tyrveil nicht an den Landepunkt zurueck, im Flug ruht nur seine Physik (vorher hing seine erste Antwort im Flugdialog, weil seine Sprechblase mit angehalten war). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
494 lines
18 KiB
GDScript
494 lines
18 KiB
GDScript
class_name DorfFall
|
|
extends Node
|
|
## Der Fall im Dorf — Akt 3 K3 als spielbare Szene (CR 48).
|
|
##
|
|
## Hängt der Kapitel-Runner unter Mikes Dorf, sobald eine Szene aus
|
|
## `schauplaetze.json` es als `ablauf` nennt, und spielt dann statt eines
|
|
## einzelnen Dialogs die drei Dateien in Segmenten mit dem Spiel dazwischen:
|
|
##
|
|
## - **`akt3_k3_dorf`:** Anflug und Ring laufen schon im Flug (Runner), der
|
|
## Rest nach der Landung. Nach `gefecht` beginnt das Gefecht — je ein
|
|
## Gegner an den drei `VeneniSpawn`-Markern, über das bestehende
|
|
## Encounter-System (CR 8), Smàladh ist in der Luft.
|
|
## - **`akt3_k3_smaladh`:** „Ich weiß, was das ist" fällt nach dem ersten
|
|
## Toten, mitten im Gefecht. Ist es gewonnen, läuft die Entscheidung bis
|
|
## vor `das_aufhoeren`; danach EIN durchgehender Encounter, damit die
|
|
## Anzeigen nacheinander wegbrechen statt zwischen zwei Kämpfen neu
|
|
## aufzutauchen. Smàladh landet, sobald er aufhört. Während der Erosion
|
|
## rückt nach, bis sie durch ist; sein Kopf dreht sich dabei einmal nach
|
|
## Nordosten — ohne Dialogbox, denn `smaladh_ruft` soll keine Anzeige haben.
|
|
## Der Schluss setzt bei `die_pfuetze` ein, dort werden die Augen schwarz.
|
|
## - **`akt3_k3_kinder`:** Die vier durchsuchbaren Häuser in beliebiger
|
|
## Reihenfolge; das nächste betretene spielt den nächsten Knoten. Danach
|
|
## entweder derselbe Weg noch einmal oder — nach `stehen_bleiben` — wird er
|
|
## zum ersten Haus zurückgeführt. In der Tür steht Imogen hinter ihm, dann
|
|
## `sie_kommt`.
|
|
##
|
|
## **Die Phasen schaltet dieses Skript nicht selbst.** GEFECHT, KOSTENLOS,
|
|
## EROSION und AUS kommen weiter aus `akt3_k3_fall.json` über die
|
|
## Dialogknoten — hier wird nur gespielt, was zwischen ihnen passiert. Kein
|
|
## Fail-State: Tyrveils Tod ist ab `gefecht` gesperrt, also endet jeder
|
|
## Encounter mit einem Sieg.
|
|
##
|
|
## **Kein Abbruch:** Wer bei der Suche stehen bleibt, wird nach einer Weile
|
|
## zum nächsten Haus geführt. Es geht trotzdem weiter.
|
|
##
|
|
## Werte und Schnittknoten: `data/story/dorf_fall.json`.
|
|
|
|
signal gefecht_begonnen(abschnitt: String)
|
|
signal gegner_gefallen(anzahl: int)
|
|
signal smaladh_gelandet
|
|
signal kopf_gedreht
|
|
signal haus_durchsucht(haus: String, durchgang: int)
|
|
signal imogen_da
|
|
|
|
const DATEI := "res://data/story/dorf_fall.json"
|
|
const ENEMY_SCRIPT := preload("res://scripts/gameplay/combat/enemy_combatant.gd")
|
|
const ENCOUNTER_SCRIPT := preload("res://scripts/gameplay/combat/combat_encounter.gd")
|
|
const KAMPF_KNOTEN := "DorfCombat"
|
|
const FALL_SEKUNDEN := 0.45
|
|
const KOPF_SEKUNDEN := 1.6
|
|
const STILLSTAND := 0.05
|
|
const SZENE_DORF := "akt3_k3_dorf"
|
|
const SZENE_SMALADH := "akt3_k3_smaladh"
|
|
const SZENE_KINDER := "akt3_k3_kinder"
|
|
|
|
var _daten: Dictionary = {}
|
|
var _encounter: CombatEncounter
|
|
var _gegner: Array[CombatActor] = []
|
|
var _tote := 0
|
|
var _nummer := 0
|
|
var _marker_index := 0
|
|
var _gefecht_gestartet := false
|
|
var _nachschub := false
|
|
var _kopf_gedreht := false
|
|
var _suche_weg := ""
|
|
var _durchsucht: Array[Node3D] = []
|
|
|
|
|
|
## Lädt die Werte, legt den Encounter-Rahmen an und hört auf die Knoten, an
|
|
## denen Bild-Beats hängen (Landung, Augen, Weg der Suche).
|
|
func _ready() -> void:
|
|
_daten = _lade()
|
|
_encounter = ENCOUNTER_SCRIPT.new()
|
|
_encounter.name = "DorfEncounter"
|
|
add_child(_encounter)
|
|
DialogueSystem.node_started.connect(_on_knoten)
|
|
|
|
|
|
## Einstieg vom Kapitel-Runner: spielt eine der drei Szenen samt dem Spiel
|
|
## zwischen ihren Segmenten. `start_knoten` ist, wo der Dialog nach dem Flug
|
|
## weiterläuft.
|
|
func spiele(scene_id: String, pfad: String, sprecher: Dictionary, start_knoten: String) -> void:
|
|
match scene_id:
|
|
SZENE_DORF:
|
|
await _dialog(pfad, sprecher, start_knoten, "")
|
|
_starte_gefecht()
|
|
SZENE_SMALADH:
|
|
await _spiele_smaladh(pfad, sprecher)
|
|
SZENE_KINDER:
|
|
await _spiele_kinder(pfad, sprecher)
|
|
_:
|
|
await _dialog(pfad, sprecher, start_knoten, "")
|
|
|
|
|
|
## Phase 1 bis zum Schluss des Falls.
|
|
func _spiele_smaladh(pfad: String, sprecher: Dictionary) -> void:
|
|
var schnitte := _schnitte(SZENE_SMALADH)
|
|
if not _gefecht_gestartet:
|
|
_starte_gefecht()
|
|
await _warte_auf_tote(int(_abschnitt("gefecht").get("smaladh_spricht_nach_toten", 1)))
|
|
await _dialog(pfad, sprecher, "", str(schnitte.get("im_gefecht_bis", "")))
|
|
await _warte_auf_ende()
|
|
await _dialog(pfad, sprecher, str(schnitte.get("im_gefecht_bis", "")), str(schnitte.get("nach_dem_gefecht_bis", "")))
|
|
_starte_letztes_gefecht()
|
|
await _warte_auf_tote(int(_abschnitt("nach_der_entscheidung").get("smaladh_hoert_auf_nach_toten", 1)))
|
|
await _dialog(pfad, sprecher, str(schnitte.get("nach_dem_gefecht_bis", "")), str(schnitte.get("aufhoeren_bis", "")))
|
|
_nachschub = true
|
|
await _warte_auf_ende()
|
|
_nachschub = false
|
|
_drehe_kopf()
|
|
await _dialog(pfad, sprecher, str(schnitte.get("schluss_ab", "")), "")
|
|
|
|
|
|
## Die Suche: vier Häuser, jedes spielt den nächsten Knoten, dann der zweite
|
|
## Durchgang oder die Rückführung, dann Imogen.
|
|
func _spiele_kinder(pfad: String, sprecher: Dictionary) -> void:
|
|
var schnitte := _schnitte(SZENE_KINDER)
|
|
var bis: Array = schnitte.get("haus_bis", [])
|
|
_suche_weg = ""
|
|
_durchsucht.clear()
|
|
var start := ""
|
|
var erstes: Node3D = null
|
|
var letztes: Node3D = null
|
|
for stopp in bis:
|
|
letztes = await _naechstes_haus()
|
|
if letztes == null:
|
|
push_error("Dorf-Suche: keine durchsuchbaren Haeuser gefunden")
|
|
break
|
|
if erstes == null:
|
|
erstes = letztes
|
|
haus_durchsucht.emit(str(letztes.name), 1)
|
|
await _dialog(pfad, sprecher, start, str(stopp))
|
|
start = str(stopp)
|
|
if _suche_weg == str(schnitte.get("nochmal", "")):
|
|
_durchsucht.clear()
|
|
for i in bis.size():
|
|
var wieder := await _naechstes_haus()
|
|
if wieder == null:
|
|
break
|
|
letztes = wieder
|
|
haus_durchsucht.emit(str(letztes.name), 2)
|
|
elif erstes != null:
|
|
await get_tree().create_timer(float(_abschnitt("suche").get("stehen_bleiben_sekunden", 6.0))).timeout
|
|
await _fuehre_zu(erstes)
|
|
letztes = erstes
|
|
_stelle_imogen_hin(letztes)
|
|
await _dialog(pfad, sprecher, str(schnitte.get("ankunft", "")), "")
|
|
|
|
|
|
## Hält die Erosion am Laufen: Solange sie nicht durch ist, rückt nach, und
|
|
## auf halber Strecke dreht Smàladh den Kopf.
|
|
func _process(_delta: float) -> void:
|
|
if not _nachschub or not _encounter.is_running or DialogueSystem.is_dialogue_active:
|
|
return
|
|
var werte := _abschnitt("nach_der_entscheidung")
|
|
if FallState.phase == FallState.Phase.EROSION and FallState.erosion() < 1.0:
|
|
if _lebende() < int(werte.get("mindestens_lebend", 2)):
|
|
var nachruecker := _baue_gegner(_naechster_marker(), werte)
|
|
_gegner.append(nachruecker)
|
|
_encounter.add_enemy(nachruecker)
|
|
if FallState.erosion() >= float(werte.get("kopf_dreht_bei_erosion", 0.5)):
|
|
_drehe_kopf()
|
|
|
|
|
|
## Knoten mit Bild-Beats: Smàladh landet, die Augen werden schwarz, der Weg
|
|
## der Suche wird gemerkt.
|
|
func _on_knoten(dialogue_id: String, node_id: String) -> void:
|
|
var schnitte := _schnitte(dialogue_id)
|
|
if dialogue_id == SZENE_SMALADH:
|
|
if node_id == str(schnitte.get("landung_bei", "")):
|
|
_zeige_smaladh(true)
|
|
smaladh_gelandet.emit()
|
|
elif node_id == str(schnitte.get("augen_bei", "")):
|
|
_schwarze_augen()
|
|
elif dialogue_id == SZENE_KINDER:
|
|
if node_id == str(schnitte.get("nochmal", "")) or node_id == str(schnitte.get("stehen_bleiben", "")):
|
|
_suche_weg = node_id
|
|
|
|
|
|
## Phase 1: je ein Gegner pro Marker, Smàladh in der Luft.
|
|
func _starte_gefecht() -> void:
|
|
if _gefecht_gestartet:
|
|
return
|
|
_gefecht_gestartet = true
|
|
_zeige_smaladh(false)
|
|
_starte_encounter(_abschnitt("gefecht"), false)
|
|
gefecht_begonnen.emit("gefecht")
|
|
|
|
|
|
## Nach der Entscheidung: wer noch steht, und die Frau vom Brunnen.
|
|
func _starte_letztes_gefecht() -> void:
|
|
var werte := _abschnitt("nach_der_entscheidung")
|
|
_starte_encounter(werte, bool(werte.get("frau_kaempft_mit", false)))
|
|
gefecht_begonnen.emit("nach_der_entscheidung")
|
|
|
|
|
|
## Baut die Gegner eines Abschnitts und startet den Encounter.
|
|
func _starte_encounter(werte: Dictionary, mit_frau: bool) -> void:
|
|
_gegner.clear()
|
|
_tote = 0
|
|
for marker in _marker():
|
|
_gegner.append(_baue_gegner(marker, werte))
|
|
var frau := _ort().get_node_or_null("Frau") as Node3D
|
|
if mit_frau and frau != null:
|
|
var label := frau.get_node_or_null("NameLabel") as Label3D
|
|
_gegner.append(_kampf_fuer(frau, label.text if label != null else "", werte))
|
|
var liste: Array = []
|
|
liste.assign(_gegner)
|
|
_encounter.start(liste)
|
|
|
|
|
|
## Eine Greybox-Figur an einem Marker, mit Kampf-Kern.
|
|
func _baue_gegner(marker: Node3D, werte: Dictionary) -> CombatActor:
|
|
_nummer += 1
|
|
var koerper := Node3D.new()
|
|
koerper.name = "Dorfgegner%d" % _nummer
|
|
var mesh_instance := MeshInstance3D.new()
|
|
mesh_instance.name = "MeshInstance3D"
|
|
var mesh := CapsuleMesh.new()
|
|
mesh.radius = 0.4
|
|
mesh.height = 1.8
|
|
var material := StandardMaterial3D.new()
|
|
material.albedo_color = _als_farbe(_abschnitt("gegner").get("farbe", []))
|
|
mesh.material = material
|
|
mesh_instance.mesh = mesh
|
|
mesh_instance.position = Vector3(0, 0.9, 0)
|
|
koerper.add_child(mesh_instance)
|
|
_ort().add_child(koerper)
|
|
koerper.global_position = marker.global_position if marker != null else Vector3.ZERO
|
|
return _kampf_fuer(koerper, str(_abschnitt("gegner").get("name", "")), werte)
|
|
|
|
|
|
## Hängt einem Körper den Kampf-Kern des Encounter-Systems an.
|
|
func _kampf_fuer(koerper: Node3D, anzeigename: String, werte: Dictionary) -> CombatActor:
|
|
var vorhanden := koerper.get_node_or_null(KAMPF_KNOTEN) as CombatActor
|
|
if vorhanden != null:
|
|
return vorhanden
|
|
var kampf: CombatActor = ENEMY_SCRIPT.new()
|
|
kampf.name = KAMPF_KNOTEN
|
|
kampf.set("enemy_name", anzeigename)
|
|
kampf.set("max_hitpoints", int(werte.get("trefferpunkte", 60)))
|
|
kampf.set("strike_damage", int(werte.get("schaden", 10)))
|
|
koerper.add_child(kampf)
|
|
kampf.died.connect(_on_gefallen.bind(koerper))
|
|
return kampf
|
|
|
|
|
|
## Ein Gegner ist gefallen: zählen, hinlegen, aus dem Weg nehmen.
|
|
func _on_gefallen(koerper: Node3D) -> void:
|
|
_tote += 1
|
|
gegner_gefallen.emit(_tote)
|
|
for kind in koerper.get_children():
|
|
if kind is CollisionShape3D:
|
|
(kind as CollisionShape3D).set_deferred("disabled", true)
|
|
var mesh := koerper.get_node_or_null("MeshInstance3D") as Node3D
|
|
if mesh == null:
|
|
return
|
|
var tween := create_tween().set_parallel(true)
|
|
tween.tween_property(mesh, "rotation:z", PI / 2.0, FALL_SEKUNDEN).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
|
|
tween.tween_property(mesh, "position:y", 0.4, FALL_SEKUNDEN).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
|
|
|
|
|
|
## Wartet, bis im laufenden Encounter so viele gefallen sind (oder er vorbei ist).
|
|
func _warte_auf_tote(anzahl: int) -> void:
|
|
while _tote < anzahl and _encounter.is_running:
|
|
await get_tree().process_frame
|
|
|
|
|
|
## Wartet, bis der laufende Encounter vorbei ist.
|
|
func _warte_auf_ende() -> void:
|
|
while _encounter.is_running:
|
|
await get_tree().process_frame
|
|
|
|
|
|
## Spielt ein Dialogsegment; läuft schon einer, erst dessen Ende abwarten.
|
|
func _dialog(pfad: String, sprecher: Dictionary, start: String, stopp: String) -> void:
|
|
while DialogueSystem.is_dialogue_active:
|
|
await DialogueSystem.dialogue_finished
|
|
DialogueSystem.start_dialogue(pfad, sprecher, start, stopp)
|
|
if DialogueSystem.is_dialogue_active:
|
|
await DialogueSystem.dialogue_finished
|
|
|
|
|
|
## Wartet, bis Tyrveil ein noch nicht durchsuchtes Haus betritt. Bleibt er
|
|
## zu lange stehen, wird er zum nächsten geführt.
|
|
func _naechstes_haus() -> Node3D:
|
|
var werte := _abschnitt("suche")
|
|
var radius := float(werte.get("radius", 2.5))
|
|
var leerlauf := float(werte.get("leerlauf_sekunden", 25.0))
|
|
var spieler := _spieler()
|
|
var steht := 0.0
|
|
var zuletzt := spieler.global_position
|
|
while _naechstes_undurchsucht(spieler) != null:
|
|
await get_tree().process_frame
|
|
for haus in _haeuser():
|
|
if _durchsucht.has(haus):
|
|
continue
|
|
if _flach(spieler.global_position).distance_to(_flach(_suchpunkt(haus).global_position)) <= radius:
|
|
_durchsucht.append(haus)
|
|
return haus
|
|
var schritt := _flach(spieler.global_position).distance_to(_flach(zuletzt))
|
|
zuletzt = spieler.global_position
|
|
steht = steht + get_process_delta_time() if schritt < STILLSTAND else 0.0
|
|
if steht >= leerlauf:
|
|
var ziel := _naechstes_undurchsucht(spieler)
|
|
await _fuehre_zu(ziel)
|
|
_durchsucht.append(ziel)
|
|
return ziel
|
|
return null
|
|
|
|
|
|
## Führt Tyrveil ohne Steuerung vor die Tür und hinein.
|
|
func _fuehre_zu(haus: Node3D) -> void:
|
|
var spieler := _spieler() as CharacterBody3D
|
|
if spieler == null or haus == null:
|
|
return
|
|
var werte := _abschnitt("suche")
|
|
var tempo := maxf(float(werte.get("gehtempo", 3.0)), 0.1)
|
|
var punkt := _suchpunkt(haus).global_position
|
|
var tuer := punkt + _tuerrichtung(haus) * float(werte.get("tuer_abstand", 4.0))
|
|
spieler.set_control_locked(true)
|
|
for ziel in [tuer, punkt]:
|
|
var nach := Vector3(ziel.x, spieler.global_position.y, ziel.z)
|
|
var tween := create_tween()
|
|
tween.tween_property(spieler, "global_position", nach, spieler.global_position.distance_to(nach) / tempo)
|
|
await tween.finished
|
|
spieler.set_control_locked(false)
|
|
|
|
|
|
## Imogen steht auf der Straße vor der Tür, hinter ihm.
|
|
func _stelle_imogen_hin(haus: Node3D) -> void:
|
|
var imogen := _ort().get_node_or_null("Imogen") as Node3D
|
|
if imogen == null or haus == null:
|
|
return
|
|
var punkt := _suchpunkt(haus).global_position
|
|
var platz := punkt + _tuerrichtung(haus) * float(_abschnitt("suche").get("imogen_abstand", 5.0))
|
|
platz.y = imogen.global_position.y
|
|
imogen.global_position = platz
|
|
imogen.visible = true
|
|
imogen.process_mode = Node.PROCESS_MODE_INHERIT
|
|
imogen_da.emit()
|
|
|
|
|
|
## Smàladh sichtbar (gelandet) oder unsichtbar (in der Luft).
|
|
func _zeige_smaladh(gelandet: bool) -> void:
|
|
var smaladh := _ort().get_node_or_null("Smaladh") as Node3D
|
|
if smaladh != null:
|
|
smaladh.visible = gelandet
|
|
|
|
|
|
## Der Kopf dreht sich einmal nach Nordosten und bleibt dort. Einmalig.
|
|
func _drehe_kopf() -> void:
|
|
if _kopf_gedreht:
|
|
return
|
|
_kopf_gedreht = true
|
|
var mesh := _ort().get_node_or_null("Smaladh/MeshInstance3D") as Node3D
|
|
var richtung := _als_vektor(_abschnitt("nach_der_entscheidung").get("blick_richtung", [1, 0, -1]))
|
|
if mesh != null and richtung.length() > 0.01:
|
|
var tween := create_tween()
|
|
tween.tween_property(mesh, "rotation:y", atan2(-richtung.x, -richtung.z), KOPF_SEKUNDEN).set_trans(Tween.TRANS_SINE)
|
|
kopf_gedreht.emit()
|
|
|
|
|
|
## Die Pfütze: Tyrveils Augen werden schwarz (CR 33d-Effekt).
|
|
func _schwarze_augen() -> void:
|
|
var spieler := _spieler()
|
|
if spieler == null:
|
|
return
|
|
var augen := spieler.get_node_or_null("MeshInstance3D/GooglyEyes") as Node3D
|
|
if augen != null:
|
|
BlackEyes.apply(augen)
|
|
|
|
|
|
## Wie viele Gegner des laufenden Abschnitts noch leben.
|
|
func _lebende() -> int:
|
|
var anzahl := 0
|
|
for kampf in _gegner:
|
|
if is_instance_valid(kampf) and kampf.is_alive():
|
|
anzahl += 1
|
|
return anzahl
|
|
|
|
|
|
## Die Marker reihum — Nachschub kommt nacheinander von allen drei Stellen.
|
|
func _naechster_marker() -> Node3D:
|
|
var marker := _marker()
|
|
if marker.is_empty():
|
|
return null
|
|
_marker_index = (_marker_index + 1) % marker.size()
|
|
return marker[_marker_index]
|
|
|
|
|
|
## Die Spawn-Marker des Dorfs.
|
|
func _marker() -> Array[Node3D]:
|
|
var liste: Array[Node3D] = []
|
|
for pfad in _abschnitt("gegner").get("marker", []):
|
|
var marker := _ort().get_node_or_null(NodePath(str(pfad))) as Node3D
|
|
if marker != null:
|
|
liste.append(marker)
|
|
return liste
|
|
|
|
|
|
## Die durchsuchbaren Häuser.
|
|
func _haeuser() -> Array[Node3D]:
|
|
var liste: Array[Node3D] = []
|
|
for pfad in _abschnitt("suche").get("haeuser", []):
|
|
var haus := _ort().get_node_or_null(NodePath(str(pfad))) as Node3D
|
|
if haus != null and _suchpunkt(haus) != null:
|
|
liste.append(haus)
|
|
return liste
|
|
|
|
|
|
## Das nächstgelegene Haus, das in diesem Durchgang noch fehlt.
|
|
func _naechstes_undurchsucht(spieler: Node3D) -> Node3D:
|
|
var bestes: Node3D = null
|
|
var abstand := INF
|
|
for haus in _haeuser():
|
|
if _durchsucht.has(haus):
|
|
continue
|
|
var d := spieler.global_position.distance_to(_suchpunkt(haus).global_position)
|
|
if d < abstand:
|
|
abstand = d
|
|
bestes = haus
|
|
return bestes
|
|
|
|
|
|
## Der SearchPoint eines Hauses.
|
|
func _suchpunkt(haus: Node3D) -> Node3D:
|
|
return haus.get_node_or_null("SearchPoint") as Node3D
|
|
|
|
|
|
## Die Tür liegt gegenüber der Rückwand; ohne Rückwand Richtung Dorfmitte.
|
|
func _tuerrichtung(haus: Node3D) -> Vector3:
|
|
var wand := haus.get_node_or_null("BackWall") as Node3D
|
|
var richtung := Vector3.ZERO
|
|
if wand != null:
|
|
richtung = haus.global_position - wand.global_position
|
|
else:
|
|
richtung = _ort().global_position - haus.global_position
|
|
richtung.y = 0.0
|
|
return richtung.normalized() if richtung.length() > 0.01 else Vector3.RIGHT
|
|
|
|
|
|
## Tyrveil im Dorf.
|
|
func _spieler() -> Node3D:
|
|
return _ort().get_node_or_null("Player") as Node3D
|
|
|
|
|
|
## Das Dorf, unter dem diese Komponente hängt.
|
|
func _ort() -> Node:
|
|
var eltern := get_parent()
|
|
return eltern if eltern != null else self
|
|
|
|
|
|
## Ein Abschnitt der Wertetabelle.
|
|
func _abschnitt(schluessel: String) -> Dictionary:
|
|
var eintrag: Variant = _daten.get(schluessel, {})
|
|
return eintrag if eintrag is Dictionary else {}
|
|
|
|
|
|
## Die Schnittknoten einer Szene.
|
|
func _schnitte(scene_id: String) -> Dictionary:
|
|
var eintrag: Variant = _abschnitt("schnitte").get(scene_id, {})
|
|
return eintrag if eintrag is Dictionary else {}
|
|
|
|
|
|
## Position ohne Höhe.
|
|
func _flach(position: Vector3) -> Vector2:
|
|
return Vector2(position.x, position.z)
|
|
|
|
|
|
## Wandelt einen Farbeintrag aus der Tabelle.
|
|
func _als_farbe(werte: Variant) -> Color:
|
|
if not (werte is Array) or werte.size() < 3:
|
|
return Color(0.4, 0.36, 0.34)
|
|
return Color(float(werte[0]), float(werte[1]), float(werte[2]))
|
|
|
|
|
|
## Wandelt einen Vektoreintrag aus der Tabelle.
|
|
func _als_vektor(werte: Variant) -> Vector3:
|
|
if not (werte is Array) or werte.size() < 3:
|
|
return Vector3.ZERO
|
|
return Vector3(float(werte[0]), float(werte[1]), float(werte[2]))
|
|
|
|
|
|
## Liest die Wertetabelle; leere Tabelle bei Fehlern.
|
|
func _lade() -> Dictionary:
|
|
if not FileAccess.file_exists(DATEI):
|
|
push_error("Dorf-Ablauf nicht lesbar: %s" % DATEI)
|
|
return {}
|
|
var geparst: Variant = JSON.parse_string(FileAccess.get_file_as_string(DATEI))
|
|
if not (geparst is Dictionary):
|
|
push_error("Dorf-Ablauf ist ungültig: %s" % DATEI)
|
|
return {}
|
|
return geparst
|