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 = Kalender (Tag 1–10 aus den Tagesplänen, heutiger ## Tag markiert), 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 FRAGMENT_PREFIX := "w1_fragment_" const NOTES_PAGE_ID := "notizen" var _is_open := false var _pages: Array[Dictionary] = [] var _page_index := 0 var _subjects: Array = [] var _codex_entries: 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- und Codex-Daten und verbindet 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") _build_pages() ## 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: _open() get_viewport().set_input_as_handled() return if not _is_open: return if event.is_action_pressed("cancel"): _close() 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() ## Baut die Seitenliste des Buchs (feste Reihenfolge). func _build_pages() -> void: _pages = [{ "id": "kalender", "title": "Kalender" }, { "id": "drache", "title": "Drache & Signet" }] 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": 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 == "kalender": return _calendar_text() 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() return "" ## Innencover: die zehn Tage von Akt 1 mit Titeln aus den Tagesplänen; ## der heutige Tag trägt Marke und Tages-Slot. func _calendar_text() -> String: var lines := PackedStringArray() lines.append("AKT 1 — DIE ZEHN TAGE") lines.append("") for day in range(1, TimeSystem.MAX_DAYS + 1): var title := str(StorySystem.get_day_plan(day).get("title", "—")) var marker := "·" if day < TimeSystem.day_count: marker = "✓" elif day == TimeSystem.day_count: marker = "▶" var line := "%s Tag %d — %s" % [marker, day, title] if day == TimeSystem.day_count: line += " (heute, %s)" % TimeSystem.get_slot_name() lines.append(line) if bool(GameState.get_story_flag("act_one_completed", false)): lines.append("") lines.append("Der zehnte Tag liegt hinter dir. Was jetzt kommt, steht in keinem Kalender.") return "\n".join(lines) ## 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 der Drachen wartet beim Dreschen." 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("SIGNET") 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 keine Beweis-Fragmente.") lines.append("") lines.append("Einberufen wird mit 20. Wren ist 16 — der Einzige, den sie früher geholt haben. Das Muster wartet darauf, gesehen zu werden: in Deveras Karten, an den Aushängen, im Gerede der Grauen.") 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]