diff --git a/data/dragons/smaladh.json b/data/dragons/smaladh.json new file mode 100644 index 0000000..6bacbac --- /dev/null +++ b/data/dragons/smaladh.json @@ -0,0 +1,34 @@ +{ + "id": "smaladh", + "name": "Smàladh", + "color_id": "schwarz", + "color_name": "Schwarz", + "tail_id": "skorpion", + "tail_name": "Skorpionschwanz", + "quality_tiers": [ + { + "id": "lodernd", + "min_quality": 75, + "label": "lodernde Glut", + "signet_strength": "außergewöhnlich", + "bond_line": "„Da bist du also. Macht und Güte — er hat beides in dir gelassen. Ich habe lange gewartet, Sohn meines Reiters. Es war nicht umsonst.“", + "reveal_line": "Die Bindung schlägt ein wie eine Flutwelle aus Hitze — kein Tasten, ein Wiedererkennen mit voller Wucht. Irgendwo unter der Asche geht ein Feuer wieder an." + }, + { + "id": "fest", + "min_quality": 50, + "label": "feste Glut", + "signet_strength": "stark", + "bond_line": "„Du stehst, wie er stand. Noch nicht so ruhig. Das kommt — oder es kostet dich. Ich bleibe lange genug, um es herauszufinden.“", + "reveal_line": "Die Bindung greift fest und warm, wie eine Hand auf der Schulter, die nicht wieder loslässt. Die Glut trägt." + }, + { + "id": "glimmend", + "min_quality": 0, + "label": "glimmende Glut", + "signet_strength": "verhalten", + "bond_line": "„Dein Vater hätte das schneller begriffen. Aber du stehst noch, und die anderen nicht. Beweise mir, dass das kein Zufall war.“", + "reveal_line": "Die Bindung greift — dünn, prüfend, wie eine Glut unter zu viel Asche. Sie hält. Was daraus wird, liegt bei dir." + } + ] +} diff --git a/docs/CHANGEREQUESTS.md b/docs/CHANGEREQUESTS.md index bcded26..c5371dc 100644 --- a/docs/CHANGEREQUESTS.md +++ b/docs/CHANGEREQUESTS.md @@ -15,21 +15,6 @@ > Vor der Umsetzung lesen: SPEC.md (§3, §5.1, §6), STORY.md (§3, §5, §6), > Smàladh.md, WELT.md. Greybox-First, alles daten-getrieben. -## 1. Bindung FIX = Smàladh — ÄNDERT die bestehende Dreschen-Logik -> Achtung: Der aktuelle Dreschen-Stand (DONE 2026-07-13) würfelt noch eine -> Zufalls-Drachenart inkl. Federschwanz-Gewichtung und einer „Vater"-Ziehstufe. -> Das wird für den Protagonisten durch eine feste Bindung ersetzt. -- Tyrveils Bindung ist **fix = Smàladh** (schwarzer Skorpionschwanz). Die - Zufalls-Artenwahl für den Protagonisten entfernen; **Federschwanz-Ausgang - streichen** (Federschwänze bleiben nur Kanon-Hintergrund via Andarna, WELT.md). -- **Dreschen-Reveal-Szene:** Smàladh (in den Chroniken „tot") tritt aus der Reihe, - Fassungslosigkeit unter Reitern/Professoren, geht auf Tyrveil zu (cineastisch; - STORY.md §5, Smàladh.md). -- Die bestehenden Daumen (Klinge/Herz, Cassian-Ausgang, Wren-/Maren-Bindung, - Drachenkunde-Wissen, NEU: Zirkel-Fortschritt) färben ab jetzt **Signet-Stärke, - Bindungsqualität und die Dramaturgie des Moments** — NICHT mehr die Drachenart. -- Bei Permadeath ON bleibt der Bindungs-Moment dramaturgisch tödlich möglich. - ## 2. „Der Zirkel" — Wahrheits-Discovery (Kaddis-Punkt 1) - **Wahrheit 1 = sammelbar:** über die 10 Tage Beweis-Fragmente finden (Deveras Battle-Brief-Karten, manipulierte Gauntlet-Zeiten am Aushang, Barks der Grauen, @@ -99,15 +84,13 @@ --- ## Phasen-Plan (Reihenfolge für den Entwickler-Claude) -> Die vier CRs in dieser Reihenfolge abarbeiten. Jede Phase ist ein **runnable +> Die CRs in dieser Reihenfolge abarbeiten. Jede Phase ist ein **runnable > Inkrement** und wandert nach Abschluss mit Notiz in CHANGEREQUESTS_DONE.md. > Nummerierung schließt an das v1-Ausbau-Programm an (Phasen 1–6 sind erledigt). +> +> _Status (2026-07-14, Claude): **Phase 7 (CR 1, Bindung FIX = Smàladh) ist +> erledigt** — siehe CHANGEREQUESTS_DONE. Nächste Phase: 8 (Lexicon)._ -- **Phase 7 — Bindung FIX = Smàladh (CR 1).** Zufalls-Drachenwahl des - Protagonisten durch feste Smàladh-Bindung ersetzen, Federschwanz-Ausgang raus, - Dreschen-Reveal-Szene. Bestehende Daumen (Klinge/Herz, Cassian, Wren/Maren, - Drachenkunde) auf **Signet-Stärke/Bindungsqualität** umstellen statt Drachenart. - Selbst-enthalten, behebt die Doc-↔-Build-Diskrepanz → **zuerst**. - **Phase 8 — Lexicon-Buch-UI (Teil CR 4).** Diegetisches Buch an der `journal`-Taste: Kalender im Innencover, Fach-Seiten (füllen sich), eigene Notizen, leeres **Muster-Board**-Register. Baut den bestehenden Codex aus. diff --git a/docs/CHANGEREQUESTS_DONE.md b/docs/CHANGEREQUESTS_DONE.md index 76bc10c..d2fa625 100644 --- a/docs/CHANGEREQUESTS_DONE.md +++ b/docs/CHANGEREQUESTS_DONE.md @@ -3,6 +3,52 @@ > Abgearbeitete Change Requests aus CHANGEREQUESTS.md, mit Datum und > Anmerkung, was geändert wurde. +## 2026-07-14 — Phase 7: Bindung FIX = Smàladh (CR 1) + +**Request:** Zufalls-Drachenwahl des Protagonisten durch die feste +Smàladh-Bindung ersetzen (schwarzer Skorpionschwanz, totgeglaubter Drache +von Tyrveils Vater — Smàladh.md); Federschwanz-Ausgang und +Vater-Ziehstufe streichen; Dreschen-Reveal-Szene (tritt aus der Reihe, +Fassungslosigkeit, geht auf Tyrveil zu); die bestehenden Daumen färben +Signet-Stärke/Bindungsqualität/Dramaturgie statt der Drachenart; +Permadeath-Todesmöglichkeit im Bindungs-Moment erhalten. + +**Umsetzung:** +- **DragonBondSystem umgebaut:** `roll_bond` liefert immer die fixe + Smàladh-Bindung (daten-getrieben aus **data/dragons/smaladh.json**: + Identität + drei Qualitäts-Stufen). Federschwanz-Gewicht, + Vater-Ziehstufe und die gewichtete Artenwahl sind entfernt; die + Lore-Drachentabelle (dragons.json) bleibt als Welt-Flavor geladen. +- **Zwei Werte statt Artenwürfel:** Das **Prüfungs-Risiko** + (compute_rejection_chance, Formel unverändert inkl. aller Daumen, + Klemme 5–35 %) ist jetzt Smàladhs Prüfung des Sohns — bei Permadeath + AN weiterhin tödlich. Neu: **compute_bond_quality (0–100)** — Basis 40, + Herz-Ton max +20, Wren+Maren max +15, Jack ±5, Cassian heart +10 / + blade −5, Drachenkunde max +9, Wren-Vertrauen ±6 — wählt die + Qualitäts-Stufe (glimmend/fest/lodernd), die **Signet-Stärke** + (verhalten/stark/außergewöhnlich) und die Bindungs-/Reveal-Zeilen der + Szene bestimmt. Der Zirkel-Fortschritt (CR 2) wird in Phase 10 als + weiterer Daumen eingehängt. +- **Dreschen-Reveal-Szene** (hatching_grounds.gd): Smàladh bricht aus + der Reihe, geht per Tween cineastisch auf Tyrveil zu, der Name „mit + Kreuz in den Chroniken" fällt; die Prüfung ersetzt die alte + Ablehnungs-Schleife (Permadeath AN: der Stachel als Urteil = Game + Over; AUS: er wendet sich ab und prüft erneut, nach 3 Fehlversuchen + bindet der Story-Modus). Kopf-an-Kopf-Stimme nach Smàladh.md, die + Stufen-Zeilen färben die Dramaturgie. Wahrheit 3 bleibt im + Bindungs-Moment. +- **Journal:** Drachen-Block zeigt jetzt Smàladh (Name, Schwarz/ + Skorpionschwanz, Chroniken-Zeile, **Bindung: **) und das Signet + mit Stärke-Zusatz. + +**Verifikation:** Sonde 25/25 grün (Qualitäts-Formel inkl. Stufen und +Klinge-/Maximalpfad, Prüfungs-Basis unverändert, fixes Bindungs-Ergebnis +ohne Feder-/Vater-Felder, kompletter Reveal-Durchlauf im Story-Modus mit +Speicherung, Epilog-Freischaltung, Journal-Anzeige). Boot-Check der +Dreschen-Szene fehlerfrei. Hinweis: Der Sonden-Durchlauf hat den +regulären Auto-Save ausgelöst — user://savegame.json enthält danach +Sonden-Stand. + ## 2026-07-13 — v1-Ausbau Phase 6: System-Anpassungen (Programm abgeschlossen) **Request:** Stat-Steigerung pro Unterrichtsraum verdrahten (SPEC §5.1); diff --git a/scripts/autoloads/dragon_bond_system.gd b/scripts/autoloads/dragon_bond_system.gd index 4eb8260..fbb2a1e 100644 --- a/scripts/autoloads/dragon_bond_system.gd +++ b/scripts/autoloads/dragon_bond_system.gd @@ -1,59 +1,66 @@ extends Node -## Drachen-Bindung beim Dreschen (Autoload, SPEC.md Abschnitte 6 und 8, -## STORY.md Abschnitt 5 Klimax). +## Drachen-Bindung beim Dreschen (Autoload, SPEC.md Abschnitt 6, +## STORY.md Abschnitt 5 Klimax, Smàladh.md; Phase 7: Bindung FIX). ## -## Basis-Zufall aus data/dragons/dragons.json (Farben: je 19, Schwarz 5; -## Schwänze: je 24, Federschwanz 4) plus LEICHTER Kompatibilitäts-Daumen: -## - Ablehnungs-Chance: Basis 20 %, minus Herz-Ton/20 (max −5, nur -## positiver Ton), minus (Wren+Maren-Beziehung)/4 (max −5), −5 bei -## jack_outcome "success" bzw. +5 bei "failed"; dazu die Phase-6-Daumen: -## Cassian-Ausgang heart −6 / blade +3, Drachenkunde-Wissen (Rotunde) -## −1 je Einheit (max −3), Wren-Vertrauen (Vertrauen−50)/25 als −2..+2; -## geklemmt auf 5–35 %. -## - Federschwanz-Gewicht: Basis 4, plus Herz-Ton/10 (max +10, nur -## positiver Ton), plus (Wren+Maren)/4 (max +5), +1 bei jack "success", -## +2 bei Cassian-Ausgang heart, +1 je Drachenkunde-Wissen (max +2), -## plus (Wren-Vertrauen−50)/25 als −2..+2 (Mindestgewicht 1) — gegen -## die übrigen Schwanz-Gewichte von je 24 (Herz-Pfad mit hoher -## Bindung hebt die Chance von ~4 % auf ~20 %; der Daumen auf der -## Waage aus STORY.md, kein garantierter Ausgang). -## - Vater-verbundener Drache (erzählerische Färbung, STORY.md Klimax): -## Chance = Herz-Ton/10 (max 10) + (Wren+Maren)/6 (max 5) Prozent, -## nur wenn kein Federschwanz gezogen wurde. -## Die Zieh-Reihenfolge in roll_bond ist fix (Ablehnung, Farbe, Schwanz, -## Vater-Bindung), damit Tests den Zufall seeden können. Konsequenz einer -## Ablehnung (Permadeath) liegt bei der Dreschen-Szene, nicht hier. +## Tyrveils Bindung ist FIX: immer Smàladh, der totgeglaubte schwarze +## Skorpionschwanz seines Vaters (data/dragons/smaladh.json). Es gibt +## keine Zufalls-Artenwahl für den Protagonisten mehr — die Drachen- +## Tabelle (data/dragons/dragons.json) bleibt nur als Welt-Flavor für +## Lore/Lexicon geladen; Federschwänze sind Kanon-Hintergrund über +## Violets Andarna, kein Spieler-Ausgang. +## +## Die Kompatibilitäts-Daumen färben stattdessen zwei Werte: +## - **Prüfungs-Risiko** (compute_rejection_chance): Smàladh prüft den +## Sohn hart. Basis 20 %, minus Herz-Ton/20 (max −5, nur positiver +## Ton), minus (Wren+Maren-Beziehung)/4 (max −5), −5 bei jack_outcome +## "success" bzw. +5 bei "failed", Cassian-Ausgang heart −6 / blade +3, +## Drachenkunde-Wissen −1 je Einheit (max −3), Wren-Vertrauen +## (Vertrauen−50)/25 als −2..+2; geklemmt auf 5–35 %. Bei Permadeath AN +## bleibt der Bindungs-Moment damit dramaturgisch tödlich möglich — +## die Konsequenz liegt bei der Dreschen-Szene, nicht hier. +## - **Bindungsqualität** (compute_bond_quality, 0–100): Basis 40, plus +## Herz-Ton/5 (max +20, nur positiver Ton), plus (Wren+Maren)/4 +## (max +15), jack "success" +5 / "failed" −5, Cassian-Ausgang +## heart +10 / blade −5, +3 je Drachenkunde-Wissen (max +9), plus +## Wren-Vertrauens-Daumen ×3 (−6..+6). Die Qualität wählt die Stufe +## aus smaladh.json (quality_tiers, absteigend nach min_quality) und +## bestimmt darüber Signet-Stärke und die Dramaturgie des Moments — +## NICHT die Drachen-Art. Der Zirkel-Fortschritt (CR 2) kommt in +## Phase 10 als weiterer Daumen dazu. +## roll_bond würfelt nur noch die eine Prüfung (seedbar); force_accept +## überspringt sie (Story-Modus nach mehreren Fehlversuchen). const DRAGONS_PATH := "res://data/dragons/dragons.json" +const SMALADH_PATH := "res://data/dragons/smaladh.json" const REJECTION_BASE := 20 const REJECTION_MIN := 5 const REJECTION_MAX := 35 -const FEATHER_BASE := 4 -const FEATHER_MIN := 1 +const QUALITY_BASE := 40 const KNOWLEDGE_FLAG := "drachenkunde_wissen" const CASSIAN_REJECTION_DELTAS := { "heart": -6, "blade": 3 } -const CASSIAN_FEATHER_DELTAS := { "heart": 2, "blade": 0 } +const CASSIAN_QUALITY_DELTAS := { "heart": 10, "blade": -5 } var _colors: Array = [] var _tails: Array = [] +var _smaladh: Dictionary = {} -## Lädt die Drachen-Tabelle beim Start. +## Lädt die Lore-Drachentabelle und die Smàladh-Akte beim Start. func _ready() -> void: - var file := FileAccess.open(DRAGONS_PATH, FileAccess.READ) - if file == null: - push_error("Drachen-Tabelle nicht lesbar: %s" % DRAGONS_PATH) - return - var parsed: Variant = JSON.parse_string(file.get_as_text()) - file.close() - if not (parsed is Dictionary) or not (parsed.get("colors") is Array) or not (parsed.get("tails") is Array): + var dragons: Variant = _load_json(DRAGONS_PATH) + if dragons is Dictionary and dragons.get("colors") is Array and dragons.get("tails") is Array: + _colors = dragons["colors"] + _tails = dragons["tails"] + else: push_error("Drachen-Tabelle ist ungültig: %s" % DRAGONS_PATH) - return - _colors = parsed["colors"] - _tails = parsed["tails"] + var smaladh: Variant = _load_json(SMALADH_PATH) + if smaladh is Dictionary and smaladh.get("quality_tiers") is Array: + _smaladh = smaladh + else: + push_error("Smàladh-Akte ist ungültig: %s" % SMALADH_PATH) -## Berechnet die aktuelle Ablehnungs-Chance in Prozent (dokumentierte +## Berechnet das aktuelle Prüfungs-Risiko in Prozent (dokumentierte ## Formel, siehe Klassen-Doku). func compute_rejection_chance() -> int: var chance := REJECTION_BASE @@ -70,47 +77,59 @@ func compute_rejection_chance() -> int: return clampi(chance, REJECTION_MIN, REJECTION_MAX) -## Berechnet das aktuelle Federschwanz-Gewicht (dokumentierte Formel, -## siehe Klassen-Doku). -func compute_feather_weight() -> int: - var weight := FEATHER_BASE - weight += clampi(maxi(GameState.blade_heart_tone, 0) / 10, 0, 10) - weight += clampi(_bond_sum() / 4, 0, 5) - if str(GameState.get_story_flag("jack_outcome", "never_encountered")) == "success": - weight += 1 - weight += int(CASSIAN_FEATHER_DELTAS.get(StorySystem.get_cassian_outcome(), 0)) - weight += clampi(_knowledge_count(), 0, 2) - weight += _wren_trust_lean() - return maxi(weight, FEATHER_MIN) +## Berechnet die Bindungsqualität 0–100 (dokumentierte Formel, siehe +## Klassen-Doku) — sie färbt Signet-Stärke und Dramaturgie des Moments. +func compute_bond_quality() -> int: + var quality := QUALITY_BASE + quality += clampi(maxi(GameState.blade_heart_tone, 0) / 5, 0, 20) + quality += clampi(_bond_sum() / 4, 0, 15) + match str(GameState.get_story_flag("jack_outcome", "never_encountered")): + "success": + quality += 5 + "failed": + quality -= 5 + quality += int(CASSIAN_QUALITY_DELTAS.get(StorySystem.get_cassian_outcome(), 0)) + quality += clampi(_knowledge_count(), 0, 3) * 3 + quality += _wren_trust_lean() * 3 + return clampi(quality, 0, 100) -## Berechnet die Chance in Prozent, dass der gebundene Drache mit Tyrveils -## Vater verbunden war (nur erzählerische Färbung). -func compute_father_chance() -> int: - var chance := clampi(maxi(GameState.blade_heart_tone, 0) / 10, 0, 10) - chance += clampi(_bond_sum() / 6, 0, 5) - return chance +## Liefert die Qualitäts-Stufe aus der Smàladh-Akte zur angegebenen +## Bindungsqualität (erste Stufe, deren min_quality erreicht ist). +func get_quality_tier(quality: int) -> Dictionary: + var tiers: Array = _smaladh.get("quality_tiers", []) + for tier in tiers: + if quality >= int(tier.get("min_quality", 0)): + return tier + if tiers.is_empty(): + return {} + return tiers.back() -## Würfelt eine Bindung: Ablehnung, dann Farbe, Schwanz und Vater-Bindung. -## force_accept überspringt die Ablehnung (Story-Modus lässt nach -## mehreren Fehlversuchen niemanden ungebunden zurück). +## Würfelt die eine Prüfung und liefert bei Bestehen die fixe +## Smàladh-Bindung samt Qualität und Stufe. force_accept überspringt +## die Prüfung (Story-Modus lässt nach mehreren Fehlversuchen niemanden +## ungebunden zurück). func roll_bond(force_accept := false) -> Dictionary: if not force_accept and randf() * 100.0 < compute_rejection_chance(): return { "accepted": false } - var color: Dictionary = _pick_weighted(_colors, "", 0) - var tail: Dictionary = _pick_weighted(_tails, "feder", compute_feather_weight()) - var is_feathertail := str(tail.get("id")) == "feder" - var is_father_connected := not is_feathertail and randf() * 100.0 < compute_father_chance() + var quality := compute_bond_quality() + var tier := get_quality_tier(quality) return { "accepted": true, - "color_id": str(color.get("id")), - "color_name": str(color.get("name")), - "tail_id": str(tail.get("id")), - "tail_name": str(tail.get("name")), - "is_black": str(color.get("id")) == "schwarz", - "is_feathertail": is_feathertail, - "is_father_connected": is_father_connected, + "dragon_id": str(_smaladh.get("id", "smaladh")), + "dragon_name": str(_smaladh.get("name", "Smàladh")), + "color_id": str(_smaladh.get("color_id", "schwarz")), + "color_name": str(_smaladh.get("color_name", "Schwarz")), + "tail_id": str(_smaladh.get("tail_id", "skorpion")), + "tail_name": str(_smaladh.get("tail_name", "Skorpionschwanz")), + "is_black": true, + "bond_quality": quality, + "quality_id": str(tier.get("id", "")), + "quality_label": str(tier.get("label", "")), + "signet_strength": str(tier.get("signet_strength", "")), + "bond_line": str(tier.get("bond_line", "")), + "reveal_line": str(tier.get("reveal_line", "")), } @@ -130,18 +149,12 @@ func _bond_sum() -> int: return maxi(RelationshipSystem.get_relationship("wren"), 0) + maxi(RelationshipSystem.get_relationship("maren"), 0) -## Gewichtete Zufallswahl aus einer Tabellen-Liste; override_id ersetzt -## das Gewicht eines Eintrags (für den Federschwanz-Daumen). -func _pick_weighted(entries: Array, override_id: String, override_weight: int) -> Dictionary: - var total := 0 - for entry in entries: - var weight := override_weight if str(entry.get("id")) == override_id else int(entry.get("weight", 0)) - total += weight - var roll := randf() * float(total) - var cursor := 0.0 - for entry in entries: - var weight := override_weight if str(entry.get("id")) == override_id else int(entry.get("weight", 0)) - cursor += float(weight) - if roll < cursor: - return entry - return entries.back() +## Lädt und parst eine JSON-Datei (null bei Fehler). +func _load_json(path: String) -> Variant: + var file := FileAccess.open(path, FileAccess.READ) + if file == null: + push_error("Datei nicht lesbar: %s" % path) + return null + var parsed: Variant = JSON.parse_string(file.get_as_text()) + file.close() + return parsed diff --git a/scripts/gameplay/hatching_grounds.gd b/scripts/gameplay/hatching_grounds.gd index 8bb87ed..6910f75 100644 --- a/scripts/gameplay/hatching_grounds.gd +++ b/scripts/gameplay/hatching_grounds.gd @@ -1,21 +1,28 @@ extends Node3D -## Ablauf-Steuerung des Dreschens (Phase 5, STORY.md Abschnitt 5 Klimax -## und Abschnitt 3 Wahrheit 3). +## Ablauf-Steuerung des Dreschens (Phase 5; Phase 7: Bindung FIX = +## Smàladh — STORY.md Abschnitt 5 Klimax, Abschnitt 3 Wahrheit 3, +## Smàladh.md). ## ## Kein Parcours: ein kurzes, atmosphärisches Bindungs-Set-Piece mit ## cineastischem Kamera-Schwenk (SPEC Abschnitt 2). Der Bindungs-Bereich -## in der Mitte startet die Sequenz: Ablehnungs- und Bindungs-Würfe über -## das DragonBondSystem (Formeln dort dokumentiert). Eine Ablehnung ist +## in der Mitte startet die Reveal-Sequenz: Smàladh — der totgeglaubte +## schwarze Skorpionschwanz von Tyrveils Vater — tritt aus der Reihe +## (Fassungslosigkeit ringsum), geht cineastisch auf Tyrveil zu und +## PRÜFT ihn (DragonBondSystem.compute_rejection_chance): Scheitern ist ## bei Permadeath AN tödlich (Game Over ins Hauptmenü); bei Permadeath -## AUS treten weitere Drachen vor, nach MAX_REJECTIONS erzwingt der -## Story-Modus eine Bindung. Wahrheit 3 wird im Moment der Bindung über -## kurze Sprechblasen-Erzähltexte erfahrbar (kein Dialogbaum) und als -## Flag gesetzt. Danach: Signet-Reveal, Speicherung in -## GameState.bound_dragon, Auto-Save, Freischaltung des Übergangs zum -## Epilog. +## AUS wendet er sich ab und prüft erneut, nach MAX_REJECTIONS erzwingt +## der Story-Modus die Bindung. Die Bindung selbst ist FIX — die Daumen +## färben über die Bindungsqualität (quality_tiers aus smaladh.json) +## Signet-Stärke und die Dramaturgie des Moments, nicht die Art. +## Smàladh spricht Kopf-an-Kopf über die Bindung (Sprechblase als +## Träger). Wahrheit 3 wird im Moment der Bindung erfahrbar. Danach: +## Signet-Reveal, Speicherung in GameState.bound_dragon, Auto-Save, +## Freischaltung des Übergangs zum Epilog. const MAIN_MENU_SCENE := "res://scenes/ui/main_menu.tscn" const MAX_REJECTIONS := 3 +const APPROACH_STOP_DISTANCE := 4.0 +const APPROACH_SECONDS := 3.0 var _has_bonding_run := false @@ -48,40 +55,40 @@ func _on_bond_trigger_entered(body: Node3D) -> void: _run_bonding(body) -## Spielt die komplette Bindung als Coroutine: Prüfung durch den Kreis, -## Ablehnungen, Wahrheit 3, Bindung, Signet-Reveal, Speicherung. +## Spielt den kompletten Reveal als Coroutine: Smàladh tritt aus der +## Reihe, geht auf Tyrveil zu, prüft ihn, bindet — Wahrheit 3, nach +## Qualität gefärbte Dramaturgie, Signet-Reveal, Speicherung. func _run_bonding(player: CharacterBody3D) -> void: player.set_control_locked(true) var player_bubble: Node3D = player.get_node("SpeechBubble") await _say(player_bubble, "Sie kreisen nicht. Sie prüfen. Als suchten sie nicht irgendwen — als erkennten sie jemanden wieder.") + await _say(player_bubble, "Dann bricht die Reihe. Hinter den Farben schiebt sich etwas Schwarzes nach vorn — zu groß, zu still. Ein segmentierter Schwanz, ein gekrümmter Stachel.") + await _approach(player) + await _say(player_bubble, "Hinter dir vergisst jemand zu atmen. Ein Professor flüstert einen Namen, der in den Chroniken ein Kreuz trägt: Smàladh. Der Drache deines Vaters.") var rejections := 0 var result := DragonBondSystem.roll_bond() while not result["accepted"]: rejections += 1 if GameState.is_permadeath_enabled: - await _say(_dragon_bubble, "Ein Schatten wendet sich ab. Kein Zorn darin. Nur ein Urteil.") - print("Game Over — das Dreschen kennt keine zweite Meinung.") + await _say(_dragon_bubble, "Der Stachel hebt sich — langsam, ohne Zorn. Ein Urteil, kein Angriff: Der Sohn ist nicht, was der Vater war.") + print("Game Over — Smàladhs Prüfung kennt keine zweite Meinung.") Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) get_tree().change_scene_to_file(MAIN_MENU_SCENE) return - await _say(_dragon_bubble, "Ein Schatten wendet sich ab — und der Kreis atmet weiter. Ein anderer tritt vor.") + await _say(_dragon_bubble, "Smàladh wendet den Kopf ab. Nicht weit. Er wartet — als hätte der Sohn seines Reiters eine zweite Antwort verdient.") result = DragonBondSystem.roll_bond(rejections >= MAX_REJECTIONS) - await _say(_dragon_bubble, "Der Blick trifft dich. Hält. Bleibt. Er sieht das Mal auf deinem Rücken — und bleibt nicht trotzdem. Er bleibt deswegen.") + await _say(_dragon_bubble, "Eine Stimme fällt in deinen Kopf wie Asche auf Glut — trocken, uralt, Kopf an Kopf: „Sie haben mich für erloschen erklärt. Ich habe gewartet.“") StorySystem.reveal_truth_3() - await _say(player_bubble, "Das ist kein Glück. Das ist Wiedererkennen. Sie wählen uns — gerade weil wir sind, was wir sind.") - if result["is_feathertail"]: - await _say(_dragon_bubble, "Klein. Golden-hell. Von allen unterschätzt — ein Federschwanz. Er erkennt, was ungebrochen ist.") - else: - await _say(_dragon_bubble, "Ein Drache in %s, %s. Er neigt den Kopf, bis ihr auf Augenhöhe seid." % [str(result["color_name"]), str(result["tail_name"])]) - if result["is_black"]: - await _say(_dragon_bubble, "Schwarz — das seltenste Blut. Irgendwo hinter dir vergisst jemand zu atmen.") - if result["is_father_connected"]: - await _say(player_bubble, "Und da ist etwas Vertrautes in seinem Blick. Als hätte er schon einmal jemanden getragen, der so stand wie du.") + await _say(player_bubble, "Das ist kein Glück. Das ist Wiedererkennen. Sie wählen uns — gerade weil wir sind, was wir sind. Und er hat auf dich gewartet. Auf DICH.") + await _say(_dragon_bubble, str(result["bond_line"])) + await _say(player_bubble, str(result["reveal_line"])) var signet: Dictionary = SignetSystem.roll_signet() await _say(player_bubble, "Hitze läuft den Arm hinauf, unter dem Relikt entlang — ein Zeichen brennt sich ein.") - await _say(player_bubble, "SIGNET: %s — %s" % [str(signet["name"]), str(signet["description"])]) + await _say(player_bubble, "SIGNET: %s (%s) — %s" % [str(signet["name"]), str(result["signet_strength"]), str(signet["description"])]) var dragon_record := result.duplicate() dragon_record.erase("accepted") + dragon_record.erase("bond_line") + dragon_record.erase("reveal_line") dragon_record["signet_id"] = str(signet["id"]) dragon_record["signet_name"] = str(signet["name"]) dragon_record["signet_description"] = str(signet["description"]) @@ -91,6 +98,18 @@ func _run_bonding(player: CharacterBody3D) -> void: player.set_control_locked(false) +## Lässt Smàladh cineastisch bis kurz vor Tyrveil herantreten. +func _approach(player: Node3D) -> void: + var to_player := player.global_position - _dragon.global_position + to_player.y = 0.0 + if to_player.length() <= APPROACH_STOP_DISTANCE: + return + var target := _dragon.global_position + to_player - to_player.normalized() * APPROACH_STOP_DISTANCE + var tween := create_tween() + tween.tween_property(_dragon, "global_position", target, APPROACH_SECONDS).set_trans(Tween.TRANS_SINE) + await tween.finished + + ## Zeigt eine Zeile über der Blase und wartet ihr Ende ab. func _say(bubble: Node3D, text: String) -> void: bubble.show_line(text) diff --git a/scripts/ui/journal.gd b/scripts/ui/journal.gd index fdc2c62..e9e2fd2 100644 --- a/scripts/ui/journal.gd +++ b/scripts/ui/journal.gd @@ -93,17 +93,16 @@ func _refresh() -> void: else: var dragon: Dictionary = GameState.bound_dragon lines.append("DEIN DRACHE") - lines.append("Farbe: %s" % str(dragon.get("color_name", "?"))) - lines.append("Schwanz: %s" % str(dragon.get("tail_name", "?"))) - if bool(dragon.get("is_black", false)): - lines.append("— Schwarz: das seltenste Blut.") - if bool(dragon.get("is_feathertail", false)): - lines.append("— Federschwanz: erkennt, was ungebrochen ist.") - if bool(dragon.get("is_father_connected", false)): - lines.append("— Etwas an ihm ist vertraut. Als hätte er schon einmal jemanden wie dich getragen.") + lines.append("%s — %s, %s" % [str(dragon.get("dragon_name", "?")), str(dragon.get("color_name", "?")), str(dragon.get("tail_name", "?"))]) + lines.append("— Schwarz: das seltenste Blut. In den Chroniken als tot geführt.") + lines.append("— Der Drache deines Vaters. Er hat gewartet.") + if not str(dragon.get("quality_label", "")).is_empty(): + lines.append("Bindung: %s" % str(dragon.get("quality_label", ""))) lines.append("") lines.append("SIGNET") - lines.append("%s — %s" % [str(dragon.get("signet_name", "?")), str(dragon.get("signet_description", ""))]) + var strength := str(dragon.get("signet_strength", "")) + var signet_title := str(dragon.get("signet_name", "?")) if strength.is_empty() else "%s (%s)" % [str(dragon.get("signet_name", "?")), strength] + lines.append("%s — %s" % [signet_title, str(dragon.get("signet_description", ""))]) for entry in _codex_entries: lines.append("") lines.append("CODEX — %s" % str(entry.get("title", "?")).to_upper())