Revidiert den Anzeige-Teil von CR 28. Die Wochentags-Loesung war richtig, solange die zehn Tage ein zusammenhaengender Zwei-Wochen-Block waren — der Buch-Kanon spannt sie aber ueber zweieinhalb Monate. Reiner Anzeige-Fix: TimeSystem.day_count (1-10) und alle Fahrplaene, Flags und Bedingungen bleiben unangetastet. Geaendert wird nur, welches Datum dazu angezeigt wird. - Neue zentrale Zuordnung data/story/kalender.json. Zentral statt je day_*.json, weil Viadukt, Gauntlet und Dreschen keine Akademietage sind und trotzdem ein Datum brauchen. - Der Stundenplan im Lexicon zeigt jetzt MONATSSEITEN (Juli, August, September, Oktober) statt zwei Wochenseiten, mit "633 AU" in der Kopfzeile. Leere Tage dazwischen stehen bewusst nicht drin. - Wochentage sind entfallen: Der Kanon nutzt Monatsnamen, aber keine belegten Wochentagsnamen. weekdays, week_label und arrival_day_name sind aus raeume.json raus, sie waren danach tot. Verifikation, Sonde 16/16: - Die vier Fixdaten stimmen: Viadukt 14. Juli, Tag 10 29. September, Gauntlet 30. September, Dreschen 1. Oktober. - Alle zehn Akademietage tragen ihr Datum aus der Tabelle. - Nirgends mehr "Tag N", kein Wochentag, kein "Woche". - Spoilerfreiheit aus CR 28 haelt: kein einziger Tagestitel steht auf einer Seite. - Kontrolle, dass wirklich nur die Anzeige betroffen ist: day_count startet bei 1, MAX_DAYS bleibt 10, und ein auf Tag 7 gesetzter Stand bleibt Tag 7 — waehrend die Seite denselben Tag korrekt als 16. September fuehrt. Boot-Check ueber sieben Szenen: 0 Fehler. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
474 lines
19 KiB
GDScript
474 lines
19 KiB
GDScript
extends CanvasLayer
|
||
## Das Lexicon — diegetische Buch-UI (Phase 8, CR 4; ersetzt das
|
||
## Journal/Codex-Grundgerüst aus Phase 5/6).
|
||
##
|
||
## Die journal-Action (J / Ⓨ△) klappt das Buch überall auf und zu, wo
|
||
## der Spieler existiert (Instanz in player.tscn); cancel schließt, der
|
||
## Button folgt dem confirm-Muster des Hauptmenüs. Geblättert wird mit
|
||
## ui_left/ui_right (Pfeiltasten / D-Pad) oder den Blätter-Buttons.
|
||
## Seiten: Innencover = **Stundenplan**, eine Seite je Kalendermonat
|
||
## (CR 34) — echte Daten statt „Tag 1–10" oder Wochentagen, je Slot das Fach
|
||
## aus dem Fahrplan. Bewusst spoilerfrei: title/beat/forced_scene der
|
||
## Tagespläne sind Autoren-Notizen und verraten kommende Ereignisse, hier
|
||
## steht nur, was Tyrveil vorher selbst wüsste. Weiter: Drache & Signet
|
||
## (Smàladh nach dem Dreschen), je eine
|
||
## Fach-Seite pro Fach aus data/lexicon/subjects.json (füllt sich über
|
||
## die Wissens-Zähler der Unterrichts-Stationen), Personen & Gerüchte
|
||
## (Codex-Einträge aus data/story/codex.json, Cassian mit
|
||
## variant_flag-Zusatz), das Muster-Board (Wahrheit-1-Fragmente aus
|
||
## Story-Flags mit Präfix w1_fragment_ — Phase 10 liefert die Sammler)
|
||
## und die eigenen Notizen (TextEdit, persistiert im Spielstand über
|
||
## GameState.lexicon_notes). Während das Buch offen ist, ist die
|
||
## Steuerung gesperrt und die Maus frei.
|
||
|
||
const SUBJECTS_PATH := "res://data/lexicon/subjects.json"
|
||
const CODEX_PATH := "res://data/story/codex.json"
|
||
const ROOMS_PATH := "res://data/story/raeume.json"
|
||
const KALENDER_PATH := "res://data/story/kalender.json"
|
||
const FRAGMENT_PREFIX := "w1_fragment_"
|
||
const FATHER_PAGE_PREFIX := "vater_seite_"
|
||
const NOTES_PAGE_ID := "notizen"
|
||
const SCHEDULE_PAGE_PREFIX := "stundenplan:"
|
||
const ARRIVAL_FLAG := "ankunft_done"
|
||
|
||
|
||
var _is_open := false
|
||
var _pages: Array[Dictionary] = []
|
||
var _page_index := 0
|
||
var _subjects: Array = []
|
||
var _codex_entries: Array = []
|
||
var _rooms: Dictionary = {}
|
||
var _kalender: Dictionary = {}
|
||
var _monate: Array = []
|
||
|
||
@onready var _title_label: Label = $Root/Book/Margin/Content/Header/TitleLabel
|
||
@onready var _page_label: Label = $Root/Book/Margin/Content/Header/PageLabel
|
||
@onready var _page_text: Label = $Root/Book/Margin/Content/PageText
|
||
@onready var _notes_edit: TextEdit = $Root/Book/Margin/Content/NotesEdit
|
||
@onready var _prev_button: Button = $Root/Book/Margin/Content/Footer/PrevButton
|
||
@onready var _next_button: Button = $Root/Book/Margin/Content/Footer/NextButton
|
||
@onready var _hint_label: Label = $Root/Book/Margin/Content/Footer/HintLabel
|
||
@onready var _close_button: Button = $Root/Book/Margin/Content/CloseButton
|
||
|
||
|
||
## Startet zugeklappt, lädt Fach-, Codex- und Raum-Daten und verbindet
|
||
## die Buttons.
|
||
func _ready() -> void:
|
||
visible = false
|
||
_close_button.pressed.connect(_close)
|
||
_prev_button.pressed.connect(_flip.bind(-1))
|
||
_next_button.pressed.connect(_flip.bind(1))
|
||
_notes_edit.text_changed.connect(_on_notes_changed)
|
||
_subjects = _load_entries(SUBJECTS_PATH, "subjects")
|
||
_codex_entries = _load_entries(CODEX_PATH, "entries")
|
||
_rooms = _load_rooms()
|
||
_kalender = _load_kalender()
|
||
_baue_monate()
|
||
_build_pages()
|
||
|
||
|
||
## Lädt die Datums-Zuordnung von Akt 1 (CR 34). Ohne sie bleibt der
|
||
## Stundenplan leer — die interne Tageszählung läuft davon unberührt weiter.
|
||
func _load_kalender() -> Dictionary:
|
||
var file := FileAccess.open(KALENDER_PATH, FileAccess.READ)
|
||
if file == null:
|
||
push_error("Kalender nicht lesbar: %s" % KALENDER_PATH)
|
||
return {}
|
||
var parsed: Variant = JSON.parse_string(file.get_as_text())
|
||
file.close()
|
||
if not (parsed is Dictionary):
|
||
push_error("Kalender ist ungültig: %s" % KALENDER_PATH)
|
||
return {}
|
||
return parsed
|
||
|
||
|
||
## Lädt die Raum-Anzeigenamen und Stundenplan-Bezeichnungen (CR 28).
|
||
func _load_rooms() -> Dictionary:
|
||
var file := FileAccess.open(ROOMS_PATH, FileAccess.READ)
|
||
if file == null:
|
||
push_error("Raum-Daten nicht lesbar: %s" % ROOMS_PATH)
|
||
return {}
|
||
var parsed: Variant = JSON.parse_string(file.get_as_text())
|
||
file.close()
|
||
if not (parsed is Dictionary) or not (parsed.get("rooms") is Dictionary):
|
||
push_error("Raum-Daten sind ungültig: %s" % ROOMS_PATH)
|
||
return {}
|
||
return parsed
|
||
|
||
|
||
## journal öffnet/schließt; cancel schließt; ui_left/ui_right blättern;
|
||
## confirm aktiviert den fokussierten Button (Controller-Pfad ohne
|
||
## ui_accept-Doppelung). Tippt der Spieler gerade Notizen, schluckt das
|
||
## TextEdit die Tasten von selbst.
|
||
func _unhandled_input(event: InputEvent) -> void:
|
||
if event.is_action_pressed("journal"):
|
||
if _is_open:
|
||
_close()
|
||
elif not DialogueSystem.is_dialogue_active and not _is_pause_open():
|
||
_open()
|
||
get_viewport().set_input_as_handled()
|
||
return
|
||
if not _is_open:
|
||
return
|
||
if event.is_action_pressed("cancel"):
|
||
_close()
|
||
get_viewport().set_input_as_handled()
|
||
return
|
||
if event.is_action_pressed("ui_left"):
|
||
_flip(-1)
|
||
return
|
||
if event.is_action_pressed("ui_right"):
|
||
_flip(1)
|
||
return
|
||
if event.is_action_pressed("confirm") and not event.is_action("ui_accept"):
|
||
_close_button.pressed.emit()
|
||
|
||
|
||
## Meldet, ob das Buch gerade offen ist (für Nachbar-UIs wie das
|
||
## Pausenmenü).
|
||
func is_open() -> bool:
|
||
return _is_open
|
||
|
||
|
||
## Meldet, ob das Pausenmenü des Spielers gerade offen ist.
|
||
func _is_pause_open() -> bool:
|
||
var pause := get_parent().get_node_or_null("PauseMenu")
|
||
return pause != null and pause.is_open()
|
||
|
||
|
||
## Baut die Seitenliste des Buchs (feste Reihenfolge).
|
||
func _build_pages() -> void:
|
||
_pages = []
|
||
for i in _monate.size():
|
||
_pages.append({
|
||
"id": "%s%d" % [SCHEDULE_PAGE_PREFIX, i + 1],
|
||
"title": "Stundenplan — %s %s" % [str(_monate[i]), str(_kalender.get("jahr", ""))],
|
||
})
|
||
_pages.append({ "id": "drache", "title": "Drache & Siegelkraft" })
|
||
for subject in _subjects:
|
||
_pages.append({ "id": "fach:%s" % str(subject.get("id", "")), "title": str(subject.get("title", "?")) })
|
||
_pages.append({ "id": "personen", "title": "Personen & Gerüchte" })
|
||
_pages.append({ "id": "muster", "title": "Muster-Board" })
|
||
_pages.append({ "id": "vater", "title": "Seiten seines Vaters" })
|
||
_pages.append({ "id": NOTES_PAGE_ID, "title": "Eigene Notizen" })
|
||
|
||
|
||
## Öffnet das Buch auf der zuletzt gelesenen Seite: Steuerung sperren,
|
||
## Maus frei, Inhalt auffrischen.
|
||
func _open() -> void:
|
||
_is_open = true
|
||
_show_page(_page_index)
|
||
visible = true
|
||
var player := get_tree().get_first_node_in_group("player")
|
||
if player != null:
|
||
player.set_control_locked(true)
|
||
Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
|
||
_close_button.grab_focus.call_deferred()
|
||
|
||
|
||
## Klappt das Buch zu und gibt Steuerung und Maus zurück; die Notizen
|
||
## stehen zu diesem Zeitpunkt bereits im GameState.
|
||
func _close() -> void:
|
||
_is_open = false
|
||
visible = false
|
||
var player := get_tree().get_first_node_in_group("player")
|
||
if player != null:
|
||
player.set_control_locked(false)
|
||
Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
|
||
|
||
|
||
## Blättert um direction Seiten weiter (mit Anschlag an den Deckeln).
|
||
func _flip(direction: int) -> void:
|
||
_show_page(_page_index + direction)
|
||
|
||
|
||
## Zeigt die Seite mit dem angegebenen Index und frischt den Inhalt auf.
|
||
func _show_page(index: int) -> void:
|
||
_page_index = clampi(index, 0, _pages.size() - 1)
|
||
var page: Dictionary = _pages[_page_index]
|
||
var page_id := str(page.get("id", ""))
|
||
_title_label.text = str(page.get("title", "?"))
|
||
_page_label.text = "Seite %d / %d" % [_page_index + 1, _pages.size()]
|
||
_prev_button.disabled = _page_index == 0
|
||
_next_button.disabled = _page_index == _pages.size() - 1
|
||
var is_notes := page_id == NOTES_PAGE_ID
|
||
_page_text.visible = not is_notes
|
||
_notes_edit.visible = is_notes
|
||
_hint_label.text = "Klick ins Blatt, um zu schreiben — gespeichert wird beim Schlafen." if is_notes else "Blättern: ◀ ▶ (Pfeiltasten / Steuerkreuz)"
|
||
if is_notes:
|
||
if _notes_edit.text != GameState.lexicon_notes:
|
||
_notes_edit.text = GameState.lexicon_notes
|
||
return
|
||
_page_text.text = _page_content(page_id)
|
||
|
||
|
||
## Übernimmt jede Notiz-Änderung sofort in den GameState (der Spielstand
|
||
## schreibt sie beim nächsten regulären Speichern mit).
|
||
func _on_notes_changed() -> void:
|
||
GameState.lexicon_notes = _notes_edit.text
|
||
|
||
|
||
## Baut den Text einer Seite aus ihrer Kennung.
|
||
func _page_content(page_id: String) -> String:
|
||
if page_id.begins_with(SCHEDULE_PAGE_PREFIX):
|
||
return _schedule_text(int(page_id.trim_prefix(SCHEDULE_PAGE_PREFIX)))
|
||
if page_id == "drache":
|
||
return _dragon_text()
|
||
if page_id.begins_with("fach:"):
|
||
return _subject_text(page_id.trim_prefix("fach:"))
|
||
if page_id == "personen":
|
||
return _persons_text()
|
||
if page_id == "muster":
|
||
return _pattern_board_text()
|
||
if page_id == "vater":
|
||
return _father_pages_text()
|
||
return ""
|
||
|
||
|
||
## Die Monate, die ueberhaupt Eintraege haben — daraus werden die
|
||
## Stundenplan-Seiten. CR 28 baute zwei Wochen-Seiten, weil zehn Tage genau
|
||
## zwei Wochen waren; der Buch-Kanon spannt sie aber ueber zweieinhalb
|
||
## Monate (CR 34), deshalb Monatsseiten.
|
||
func _baue_monate() -> void:
|
||
_monate = []
|
||
for monat in _kalender.get("monate", []):
|
||
if not _eintraege_im_monat(str(monat)).is_empty():
|
||
_monate.append(str(monat))
|
||
|
||
|
||
## Alle Eintraege eines Monats in Datums-Reihenfolge: Ankunftstag,
|
||
## Akademietage, danach die festen Termine (Gauntlet, Dreschen).
|
||
func _eintraege_im_monat(monat: String) -> Array:
|
||
var eintraege: Array = []
|
||
var ankunft: Dictionary = _kalender.get("ankunft", {})
|
||
if str(ankunft.get("monat", "")) == monat:
|
||
eintraege.append({ "art": "ankunft", "datum": str(ankunft.get("datum", "")) })
|
||
var tage: Dictionary = _kalender.get("tage", {})
|
||
for nummer in range(1, TimeSystem.MAX_DAYS + 1):
|
||
var eintrag: Dictionary = tage.get(str(nummer), {})
|
||
if str(eintrag.get("monat", "")) == monat:
|
||
eintraege.append({ "art": "tag", "tag": nummer, "datum": str(eintrag.get("datum", "")) })
|
||
for fix in _kalender.get("fixpunkte", []):
|
||
if str(fix.get("monat", "")) == monat:
|
||
eintraege.append({ "art": "fix", "datum": str(fix.get("datum", "")), "label": str(fix.get("label", "")) })
|
||
return eintraege
|
||
|
||
|
||
## Das Anzeige-Datum eines Akademietages (CR 34). Die interne Zaehlung
|
||
## (TimeSystem.day_count 1-10) bleibt davon unberuehrt.
|
||
func _datum(day: int) -> String:
|
||
var eintrag: Dictionary = _kalender.get("tage", {}).get(str(day), {})
|
||
return str(eintrag.get("datum", "Tag %d" % day))
|
||
|
||
|
||
## Stundenplan eines Kalendermonats: je Termin eine Zeile mit Datum,
|
||
## darunter die drei Slots. Gezeigt wird ausschliesslich das Fach aus den
|
||
## offenen Raeumen des Fahrplans — nie title/beat/forced_scene, die
|
||
## kommende Ereignisse verraten wuerden. Leere Tage dazwischen stehen
|
||
## bewusst nicht drin (CR 34: kein „nichts passiert"-Rauschen).
|
||
func _schedule_text(monat_nummer: int) -> String:
|
||
var index := monat_nummer - 1
|
||
if index < 0 or index >= _monate.size():
|
||
return ""
|
||
var lines := PackedStringArray()
|
||
for eintrag in _eintraege_im_monat(str(_monate[index])):
|
||
match str(eintrag.get("art", "")):
|
||
"ankunft":
|
||
lines.append(_arrival_line(str(eintrag.get("datum", ""))))
|
||
"fix":
|
||
lines.append("· %s — %s" % [str(eintrag.get("datum", "")), str(eintrag.get("label", ""))])
|
||
_:
|
||
var tag := int(eintrag.get("tag", 0))
|
||
lines.append(_day_headline(tag))
|
||
lines.append(" %s" % _slot_summary(tag))
|
||
if index == _monate.size() - 1 and bool(GameState.get_story_flag("act_one_completed", false)):
|
||
lines.append("")
|
||
lines.append("Der Plan endet hier. Was danach kommt, steht in keinem Stundenplan.")
|
||
return "
|
||
".join(lines)
|
||
|
||
|
||
## Der Viadukt-Tag steht vor der Zählung — eigener Name, keine Nummer.
|
||
func _arrival_line(datum: String) -> String:
|
||
if bool(GameState.get_story_flag(ARRIVAL_FLAG, false)):
|
||
return "✓ %s — angekommen." % datum
|
||
return "▶ %s — heute." % datum
|
||
|
||
|
||
## Kopfzeile eines Tages mit Fortschritts-Marke.
|
||
func _day_headline(day: int) -> String:
|
||
var marker := "·"
|
||
if day < TimeSystem.day_count:
|
||
marker = "✓"
|
||
elif day == TimeSystem.day_count:
|
||
marker = "▶"
|
||
var line := "%s %s" % [marker, _datum(day)]
|
||
if day == TimeSystem.day_count and bool(GameState.get_story_flag(ARRIVAL_FLAG, false)):
|
||
line += " (heute, %s)" % TimeSystem.get_slot_name()
|
||
return line
|
||
|
||
|
||
## Die drei Slots eines Tages als eine Zeile: „Vm Gefechtskunde · Nm frei".
|
||
func _slot_summary(day: int) -> String:
|
||
var parts := PackedStringArray()
|
||
var short_names: Dictionary = _rooms.get("slot_short", {})
|
||
for slot in TimeSystem.SLOT_IDS.values():
|
||
var label := str(short_names.get(slot, str(slot).left(2)))
|
||
parts.append("%s %s" % [label, _subjects_for_slot(day, str(slot))])
|
||
return " ".join(parts)
|
||
|
||
|
||
## Die Fächer eines Slots aus den laut Fahrplan offenen Räumen. Räume
|
||
## ohne schedule-Eintrag (Hof, Aula, Schlafsaal, Imogens Zimmer) sind
|
||
## kein Unterricht und tauchen nicht auf. Alphabetisch sortiert, damit
|
||
## dasselbe Fach an jedem Tag an derselben Stelle steht — ein Plan, den
|
||
## man überfliegen kann, statt der Array-Reihenfolge des Fahrplans.
|
||
func _subjects_for_slot(day: int, slot_id: String) -> String:
|
||
var rooms: Dictionary = _rooms.get("rooms", {})
|
||
var subjects := PackedStringArray()
|
||
for room_id in StorySystem.get_slot_plan(day, slot_id).get("rooms", []):
|
||
var label := str(rooms.get(str(room_id), {}).get("schedule", ""))
|
||
if not label.is_empty() and not label in subjects:
|
||
subjects.append(label)
|
||
if subjects.is_empty():
|
||
return str(_rooms.get("free_slot_label", "frei"))
|
||
subjects.sort()
|
||
return " · ".join(subjects)
|
||
|
||
|
||
## Drachen-Seite: Smàladh samt Bindungs-Stufe — oder der Platzhalter vor
|
||
## dem Dreschen. Die Siegelkraft erscheint erst, wenn sie in Akt 2 K2
|
||
## enthüllt wurde (CR 35): vorher steht dort nichts, auch kein
|
||
## Platzhalter, der die noch nicht manifestierte Kraft verraten würde.
|
||
func _dragon_text() -> String:
|
||
if not GameState.has_bound_dragon():
|
||
return "Noch keine Bindung.\n\nDer Kreis wartet beim Dreschen. Angeblich sucht er sich aus, wer hineingeht."
|
||
var dragon: Dictionary = GameState.bound_dragon
|
||
var lines := PackedStringArray()
|
||
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", "")))
|
||
if SignetSystem.is_first_signet_revealed():
|
||
lines.append("")
|
||
lines.append("SIEGELKRAFT")
|
||
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", ""))])
|
||
return "\n".join(lines)
|
||
|
||
|
||
## Fach-Seite: Einträge erscheinen, sobald der Wissens-Zähler des Fachs
|
||
## ihre min_count erreicht (die Seite füllt sich mit gelerntem Wissen).
|
||
func _subject_text(subject_id: String) -> String:
|
||
for subject in _subjects:
|
||
if str(subject.get("id", "")) != subject_id:
|
||
continue
|
||
var count := int(GameState.get_story_flag(str(subject.get("counter_flag", "")), 0))
|
||
var lines := PackedStringArray()
|
||
for entry in subject.get("entries", []):
|
||
if count >= int(entry.get("min_count", 1)):
|
||
if not lines.is_empty():
|
||
lines.append("")
|
||
lines.append(str(entry.get("text", "")))
|
||
if lines.is_empty():
|
||
return str(subject.get("empty_line", "Noch keine Aufzeichnungen."))
|
||
return "\n".join(lines)
|
||
return ""
|
||
|
||
|
||
## Personen-Seite: die Codex-Einträge (Cassian mit Flag-Variante,
|
||
## Professoren, „Die Grauen").
|
||
func _persons_text() -> String:
|
||
var lines := PackedStringArray()
|
||
for entry in _codex_entries:
|
||
if not lines.is_empty():
|
||
lines.append("")
|
||
lines.append(str(entry.get("title", "?")).to_upper())
|
||
lines.append(str(entry.get("body", "")))
|
||
var variant := _entry_variant(entry)
|
||
if not variant.is_empty():
|
||
lines.append(variant)
|
||
return "\n".join(lines)
|
||
|
||
|
||
## Muster-Board: trägt die Leitfrage des Wahrheit-1-Strangs (CR 2) und
|
||
## listet gesammelte Beweis-Fragmente (Story-Flags mit Präfix
|
||
## w1_fragment_); leer bleibt es ein wartendes Register.
|
||
func _pattern_board_text() -> String:
|
||
var lines := PackedStringArray()
|
||
lines.append("WARUM IST WREN MIT 16 HIER?")
|
||
lines.append("")
|
||
var has_fragments := false
|
||
for flag_name in GameState.story_flags:
|
||
if not str(flag_name).begins_with(FRAGMENT_PREFIX):
|
||
continue
|
||
var value: Variant = GameState.story_flags[flag_name]
|
||
if value is String and not str(value).is_empty():
|
||
lines.append("• %s" % str(value))
|
||
has_fragments = true
|
||
elif bool(value):
|
||
lines.append("• %s" % str(flag_name).trim_prefix(FRAGMENT_PREFIX).capitalize())
|
||
has_fragments = true
|
||
if not has_fragments:
|
||
lines.append("Noch nichts, was ich jemandem hinlegen könnte.")
|
||
lines.append("")
|
||
lines.append("Einberufen wird mit 20. Wren ist 16. Der Einzige. — Deveras Karten. Die Aushänge. Das Gerede der Grauen. Irgendwo davon fällt es raus.")
|
||
lines.append("")
|
||
lines.append("Zirkel-Fortschritt: %d/100" % StorySystem.get_zirkel_progress())
|
||
if bool(GameState.get_story_flag(StorySystem.FLAG_ZIRKEL_BESTAETIGT, false)):
|
||
lines.append("Xaden hat das Muster bestätigt — der Zirkel sieht es jetzt mit dir.")
|
||
return "\n".join(lines)
|
||
|
||
|
||
## Seiten seines Vaters: die seltenen Blätter aus „Blätter jagen"
|
||
## (CR 12, Story-Flags mit Präfix vater_seite_). Kein Beweis-Register —
|
||
## eine Sammlung seiner Handschrift. Was er wirklich getan hat, steht
|
||
## hier bewusst nicht; das erfährt Tyrveil von Mira.
|
||
func _father_pages_text() -> String:
|
||
var lines := PackedStringArray()
|
||
var found := PackedStringArray()
|
||
for flag_name in GameState.story_flags:
|
||
if not str(flag_name).begins_with(FATHER_PAGE_PREFIX):
|
||
continue
|
||
var value: Variant = GameState.story_flags[flag_name]
|
||
if value is String and not str(value).is_empty():
|
||
found.append("• %s" % str(value))
|
||
if found.is_empty():
|
||
lines.append("Noch nichts von ihm.")
|
||
lines.append("")
|
||
lines.append("Sie haben seinen Namen aus den Chroniken gestrichen und die Papiere verbrannt. Basgiath ist alt, und der Wind ist gründlicher als sie.")
|
||
return "\n".join(lines)
|
||
lines.append("SEINE HANDSCHRIFT")
|
||
lines.append("")
|
||
lines.append_array(found)
|
||
lines.append("")
|
||
lines.append("Kein Beweis. Nur er.")
|
||
return "\n".join(lines)
|
||
|
||
|
||
## Liefert den Flag-abhängigen Zusatztext eines Codex-Eintrags
|
||
## (leer, wenn der Eintrag keine Varianten hat oder keine passt).
|
||
func _entry_variant(entry: Dictionary) -> String:
|
||
var variants: Dictionary = entry.get("variants", {})
|
||
var flag_name := str(entry.get("variant_flag", ""))
|
||
if variants.is_empty() or flag_name.is_empty():
|
||
return ""
|
||
var flag_value := str(GameState.get_story_flag(flag_name, ""))
|
||
return str(variants.get(flag_value, ""))
|
||
|
||
|
||
## Lädt eine JSON-Datei und liefert das Array unter dem angegebenen
|
||
## Schlüssel (leer bei Fehler, mit Log).
|
||
func _load_entries(path: String, key: String) -> Array:
|
||
var file := FileAccess.open(path, FileAccess.READ)
|
||
if file == null:
|
||
push_error("Lexicon-Daten nicht lesbar: %s" % path)
|
||
return []
|
||
var parsed: Variant = JSON.parse_string(file.get_as_text())
|
||
file.close()
|
||
if not (parsed is Dictionary) or not (parsed.get(key) is Array):
|
||
push_error("Lexicon-Daten ungültig: %s" % path)
|
||
return []
|
||
return parsed[key]
|