windgeschworen/scripts/ui/lexicon.gd
danny 3ebfad5374 CR 34: Echte Kalenderdaten statt "Tag N" und Wochentage
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>
2026-09-12 14:40:28 +02:00

474 lines
19 KiB
GDScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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]