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 Akademie-Woche ## (CR 28) — echte Wochentage statt „Tag 1–10", darunter 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 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" const DAYS_PER_WEEK := 5 var _is_open := false var _pages: Array[Dictionary] = [] var _page_index := 0 var _subjects: Array = [] var _codex_entries: Array = [] var _rooms: Dictionary = {} @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() _build_pages() ## 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 week in _week_count(): _pages.append({ "id": "%s%d" % [SCHEDULE_PAGE_PREFIX, week + 1], "title": "Stundenplan — %s" % (str(_rooms.get("week_label", "Woche %d")) % (week + 1)), }) _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 "" ## Innencover: die zehn Tage von Akt 1 mit Titeln aus den Tagesplänen; ## der heutige Tag trägt Marke und Tages-Slot. func _week_count() -> int: return ceili(float(TimeSystem.MAX_DAYS) / float(DAYS_PER_WEEK)) ## Der Anzeigename eines Akademie-Tages: echte Wochentage über zwei ## Wochen (CR 28), Tag 1 = Montag der ersten Woche. Die interne Zählung ## (TimeSystem.day_count 1–10) bleibt davon unberührt. func _weekday_name(day: int) -> String: var weekdays: Array = _rooms.get("weekdays", []) if weekdays.is_empty(): return "Tag %d" % day return str(weekdays[(day - 1) % weekdays.size()]) ## Stundenplan einer Akademie-Woche: je Tag eine Zeile mit den drei ## Slots. Gezeigt wird ausschließlich das Fach aus den offenen Räumen des ## Fahrplans — nie title/beat/forced_scene, die kommende Ereignisse ## verraten würden. func _schedule_text(week: int) -> String: var lines := PackedStringArray() var first_day := (week - 1) * DAYS_PER_WEEK + 1 if week <= 1: lines.append(_arrival_line()) lines.append("") for day in range(first_day, mini(first_day + DAYS_PER_WEEK, TimeSystem.MAX_DAYS + 1)): lines.append(_day_headline(day)) lines.append(" %s" % _slot_summary(day)) if week >= _week_count() 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 "\n".join(lines) ## Der Viadukt-Tag steht vor der Zählung — eigener Name, keine Nummer. func _arrival_line() -> String: var name := str(_rooms.get("arrival_day_name", "Ankunftstag")) if bool(GameState.get_story_flag(ARRIVAL_FLAG, false)): return "✓ %s — angekommen." % name return "▶ %s — heute." % name ## 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, _weekday_name(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 und Signet — oder der ## Platzhalter vor dem Dreschen. 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", ""))) 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]