Alle Dialogbaeume und alle Lexicon-/Codex-Texte gegen die sechs Anti-Muster neu geschrieben. Xaden zuerst und am gruendlichsten, dann Violet und Imogen. Abgesichert, bevor geschrieben wurde: ein Strukturabdruck aller 79 Datendateien aus dem Commit-Stand — alles ausser den Texten, also Knoten, Optionen, next-Ziele, blade_heart, relationship, Flags und Listenlaengen. Nach dem Pass neu erzeugt und verglichen: keine einzige Abweichung. Ton ungleich Ausgang ist damit belegt, nicht behauptet. Der Abdruck selbst musste dabei korrigiert werden, er hatte abort_lines und variants nicht maskiert und meldete sechs Falschtreffer. xaden_intro trug alle sechs Muster auf einmal. Aus "erst mal eine Wand angestarrt" wurde "Ich hab ihn dreimal gelesen" — dasselbe Gefuehl, aber als Handlung. Anapher, Antithese, das erklaerende "Du weisst, wie ich das meine" und die Beziehungs-Exposition sind ersatzlos weg. Xadens Zeilen kommen jetzt im Schnitt mit 27 Woertern aus, die laengste mit 41. Violet und Imogen gestrafft, nicht umgebaut. Imogens Antithese bleibt stehen, sie ist ihr Dilemma und keine Dekoration; nur ihr Kommentar darunter faellt weg. Bei Cassian sind der Meta-Callback und Tyrveils ausgesprochenes Thema raus. Das Lexicon ist jetzt Tyrveils Buch: Fach-Seiten, Codex und die Erzaehltexte in lexicon.gd trocken und aus seiner Sicht. Kein Eintrag erklaert mehr seine eigene Bedeutung. Fakten, Zaehler, Varianten und Freischalt-Logik sind unangetastet. Bewusst stehen gelassen: 16 Detektor-Treffer auf Muster 3, allesamt Stammeln unter Druck. Das ist naturalistische Rede, nicht die Buehnensprache, die der CR meint. Verifiziert mit dev_cr19_probe (26/26), dem Strukturvergleich mit null Abweichungen und einem Boot-Check ueber elf Szenen; Sonde vor dem Commit geloescht. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
332 lines
13 KiB
GDScript
332 lines
13 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 = 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 FATHER_PAGE_PREFIX := "vater_seite_"
|
||
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 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 = [{ "id": "kalender", "title": "Kalender" }, { "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 == "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()
|
||
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 _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("Zehn Tage abgehakt. Ab hier hört der Kalender auf zu helfen.")
|
||
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 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]
|