From df795ef40d516ffc0175a7d9e7187b014f654c24 Mon Sep 17 00:00:00 2001 From: danny Date: Sat, 4 Jul 2026 16:25:59 +0200 Subject: [PATCH] Phase 1a: GameState-Logik, Save/Load, Hauptmenue, Imogen-Testfall - GameState: Stats, Klinge-Herz-Achse, Beziehungen, Menschlichkeit, Permadeath inkl. Klemmung, Signalen und Save-Serialisierung - RelationshipSystem als Zugriffs-Fassade ueber GameState - SaveSystem: JSON-Save/Load nach user:// mit Fehlerbehandlung - Hauptmenue (neue Main Scene): Start/Fortsetzen/Beenden, fokus-navigierbar mit Tastatur und Controller, Fortsetzen nur bei vorhandenem Save - Imogen-Platzhalter in test_ground: Area3D-Trigger, Prompt, Konsolen-Zeile, Beziehungs-Zuwachs (NPC-ID imogen) mit 2-s-Cooldown - Debug-Overlay: Stats, Klinge-Herz, Beziehung Imogen, Permadeath - Interim: menu-Action in der Testszene speichert und kehrt ins Menue zurueck - Input-Map: slide (C/L2) und jump (Leertaste/A-Kreuz) laut neuer SPEC 9 verdrahtet, Mechanik folgt in Phase 1b - SPEC-Update (Roadmap, slide/jump) und Phase-1a-Prompt eingecheckt Co-Authored-By: Claude Fable 5 --- docs/SPEC.md | 16 +-- project.godot | 14 ++- prompts/phase-1a.md | 60 +++++++++++ scenes/test_ground.tscn | 56 +++++++++- scenes/ui/main_menu.tscn | 58 ++++++++++ scripts/autoloads/game_state.gd | 131 ++++++++++++++++++++++- scripts/autoloads/relationship_system.gd | 28 ++++- scripts/autoloads/save_system.gd | 53 ++++++++- scripts/gameplay/npc_placeholder.gd | 60 +++++++++++ scripts/gameplay/test_ground.gd | 15 +++ scripts/ui/debug_overlay.gd | 10 +- scripts/ui/main_menu.gd | 50 +++++++++ 12 files changed, 523 insertions(+), 28 deletions(-) create mode 100644 prompts/phase-1a.md create mode 100644 scenes/ui/main_menu.tscn create mode 100644 scripts/gameplay/npc_placeholder.gd create mode 100644 scripts/gameplay/test_ground.gd create mode 100644 scripts/ui/main_menu.gd diff --git a/docs/SPEC.md b/docs/SPEC.md index 7f08987..081a103 100644 --- a/docs/SPEC.md +++ b/docs/SPEC.md @@ -100,20 +100,20 @@ Tastatur + Xbox/PS5. Deadzone 0.2 für Sticks/Trigger. - `menu` — Tab / Start (6) - `journal` — J / Ⓨ △ (3) - `sprint` — Shift / linker Stick-Klick (7) +- `slide` — C / Linker Trigger (L2/LT) (Zum Rutschen auf dem Boden) +- `jump` — Leertaste / Ⓐ / ✕ (Wird beim Laufen gegen Wände automatisch für das Klettern/Hochziehen getriggert) UI nutzt `confirm`/`cancel`/`menu` + Focus-Navigation. ## 10. Phasen-Roadmap - **Phase 0** — Setup, .gitignore, Input-Map, Autoload-Skelette, Greybox- Testszene mit Third-Person-Controller (WoW-Zoom), Controller + Tastatur laufen, Debug-Overlay. Runnable. -- **Phase 1** — Tageszyklus + Stats + Save/Load + Greybox-Hub (Reiterquadrant, - Schlafsaal, Klassenraum). -- **Phase 2** — Dialog-System + erste NPCs (Violet, Imogen, Rhiannon, Wren). -- **Phase 3** — Viadukt-Set-Piece + Charakter-Anlage + Klinge/Herz-Achse. -- **Phase 4** — Unterricht, Gauntlet, Beziehungs-/Fraktions-Logik, - Maren-Wendepunkt (Wahrheit 1 & 2). -- **Phase 5** — Dreschen + Bindungs-RNG + Signet-Reveal + Wahrheit 3 + Teaser. -- **Phase 6** — Codex, Mature-Gate, Permadeath-Toggle, Button-Prompts, Polish. +- **Phase 1** — Fundament, Zeit & Werte: Tageszyklus (Vormittag/Nachmittag/Abend, Schlafsaal beendet Tag), Stats (Kraft/Schnelligkeit/Verstand). NEU: Klinge-↔-Herz-Achse und NPC-Beziehungsdaten werden als leere Datenstrukturen/Variablen im GameState angelegt. Save/Load-System für alle diese Werte. Minimalistisches Hauptmenü (Start, Fortsetzen, Beenden). Movement-Upgrade: Erweiterung des Phase-0-Controllers um eine Rutsch-Mechanik (Slide via `slide`) und ein einfaches Klettersystem (automatisches Hochziehen an Kanten bei Wand-Kollision im Sprung). Greybox-Hub (Reiterquadrant, Schlafsaal, Klassenraum aus Primitiven) inklusive Zonen-Wechsel. Einfaches UI-Debug-Overlay zur Werte-Überprüfung. +- **Phase 2** — Dialog-System + erste NPCs (Violet, Imogen, Rhiannon, Wren). Entscheidungen verändern aktiv die Klinge-↔-Herz-Achse und die NPC-Beziehungswerte. +- **Phase 3** — Viadukt-Set-Piece + Charakter-Anlage. Das eigentliche Action-/Geschicklichkeits-Segment auf dem Viadukt im Greybox-Stil (Rettung von Wren, Beeinflussung durch Klinge/Herz-Wahl, Permadeath-Option). +- **Phase 4** — Akademie-Alltag, Sparring & Marens Wendepunkt: Implementierung eines stat-basierten, taktischen Sparring-Systems im Reiterquadranten (Werte-Checks für Kraft/Schnelligkeit/Verstand + taktische Klinge/Herz-Entscheidungen). Integration von Jack-Barlowe-Hinterhalten mit tödlichen Quick-Time-Events (QTE) via Input-Actions (Kopplung an Permadeath). Unterrichtsstunden zur Stat-Steigerung, Fraktions-Standing der Gezeichneten. Der Gauntlet-Lauf als manipuliertes Skill-Gate. Story-Klimax 1: Marens fixer Tod, Reveal von Wahrheit 1 & 2. +- **Phase 5** — Dreschen + Bindungs-RNG + Signet-Reveal + Wahrheit 3 + Teaser. Erweiterung: Der Ausgang des Jack-Barlowe-Konflikts aus Phase 4 fließt als zusätzlicher Daumen auf der Waage in die Drachen-Kompatibilität ein. +- **Phase 6** — Codex, Mature-Gate, Permadeath-Toggle, Button-Prompts, Polish. Austausch der Greybox-Primitive gegen die CC0-Low-Poly-Assets und Texturen. ## 11. NICHT in v1 (Out of Scope) Flug-Gameplay, offene Welt, echte 3D-Assets, Multiplayer, spätere Jahre, diff --git a/project.godot b/project.godot index c44d279..447f354 100644 --- a/project.godot +++ b/project.godot @@ -16,7 +16,7 @@ compatibility/default_parent_skeleton_in_mesh_instance_3d=true config/name="Windgeschworen" config/description="Third-Person-RPG - erstes Ausbildungsjahr an einer Drachenreiter-Akademie. Privates Fan-Projekt." -run/main_scene="res://scenes/test_ground.tscn" +run/main_scene="res://scenes/ui/main_menu.tscn" config/features=PackedStringArray("4.7", "Forward Plus") [autoload] @@ -124,3 +124,15 @@ sprint={ , Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":7,"pressure":0.0,"pressed":false,"script":null) ] } +slide={ +"deadzone": 0.2, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":67,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +, Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":4,"axis_value":1.0,"script":null) +] +} +jump={ +"deadzone": 0.2, +"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":32,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null) +, Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":0,"pressure":0.0,"pressed":false,"script":null) +] +} diff --git a/prompts/phase-1a.md b/prompts/phase-1a.md new file mode 100644 index 0000000..dc62395 --- /dev/null +++ b/prompts/phase-1a.md @@ -0,0 +1,60 @@ +# Phase 1a — Kickoff-Prompt für Claude Code + +Du arbeitest weiter an "Windgeschworen" (Godot 4.7, GDScript). Lies vor Beginn +docs/SPEC.md, docs/STORY.md und docs/CHARACTERS.md erneut vollständig — die +SPEC wurde seit Phase 0 aktualisiert. Halte dich an die Konventionen aus +SPEC.md Abschnitt 3 (keine Inline-Kommentare, nur ##-Doku-Blöcke über +Funktionen/Klassen). + +Umfang Phase 1a (NUR das, nichts aus 1b vorwegnehmen): + +1. GameState (scripts/autoloads/game_state.gd) mit echter Logik füllen: + - Stats: strength, agility, intellect (int, Startwerte niedrig-mittel, + Methode zum Erhöhen mit Klemmen an ein Maximum). + - Klinge-↔-Herz-Achse: int blade_heart_tone, Bereich -100..100, Methode + zum Verschieben mit Klemmung, Signal bei Änderung. + - Beziehungswerte: Dictionary NPC-ID -> int (-100..100), Methoden zum + Lesen, Setzen und relativen Verschieben, Signal bei Änderung. + - Menschlichkeits-Messwert: int, verdeckt, gleiche Mechanik wie Klinge/Herz, + aber ohne UI-Anzeige in Phase 1. + - Permadeath-Toggle: bool, Default true. + +2. SaveSystem (scripts/autoloads/save_system.gd): speichert und lädt den + kompletten GameState-Zustand (Stats, Ton-Wert, Beziehungen, Menschlichkeit, + Permadeath-Flag) als JSON nach user://. Methoden save_game() und + load_game(), sinnvolle Fehlerbehandlung falls keine Datei existiert. + +3. Minimalistisches Hauptmenü (neue Szene scenes/ui/main_menu.tscn + + zugehöriges Script): Start (neues Spiel, resettet GameState), Fortsetzen + (nur aktiv/sichtbar wenn ein Save existiert, ruft SaveSystem.load_game()), + Beenden. Vollständig per Tastatur UND Controller bedienbar (Focus- + Navigation, confirm/cancel-Actions aus der Input-Map). Setze main_menu.tscn + als neue Main Scene; test_ground.tscn wird über "Start" geladen. + +4. Imogen als minimaler Testfall für RelationshipSystem (NICHT das volle + Dialog-System aus Phase 2 vorwegnehmen): + - Kleiner Platzhalter-Charakter in test_ground.tscn: eigene Kapsel-Farbe + oder simples Label "Imogen" über dem Kopf, damit sie vom Spieler + unterscheidbar ist. + - Interagierbar über die interact-Action in Reichweite (Area3D-Trigger + + Prompt-Hinweis, z. B. im Debug-Overlay oder als simples 3D-Label + "E / Ⓐ - Reden"). + - Bei Interaktion: ein fest hinterlegter Platzhaltersatz wird in der + Godot-Konsole ausgegeben (kein UI-Textfenster, das ist Phase 2), UND + RelationshipSystem wird für die NPC-ID "imogen" um einen kleinen + Testwert erhöht. Cooldown, damit Spam-Interaktion nicht den Wert + durchknallt. + - Nutze exakt die NPC-ID "imogen" als Konvention für Phase 2. + +5. Debug-Overlay erweitern: zeige zusätzlich Stats (Kraft/Schnelligkeit/ + Verstand), Klinge-↔-Herz-Wert, Beziehungswert zu Imogen, Permadeath-Status. + Menschlichkeits-Messwert bewusst NICHT anzeigen (verdeckt laut SPEC). + +Nicht in diesem Schritt: Slide/Klettern, Greybox-Hub mit drei Räumen, +Zonen-Wechsel, echtes Dialog-System — das ist Phase 1b bzw. Phase 2. + +Vorgehen: kleine nachvollziehbare Schritte, kurz erklären was du tust, am Ende +committen (kein Push), knappe Test-Anleitung (Menü testen, Save/Load testen, +Imogen ansprechen und Wert im Overlay beobachten), offene Punkte für Phase 1b +auflisten. STOPP nach Phase 1a und auf Review warten. Bei Unklarheiten in den +Docs: nachfragen statt raten. \ No newline at end of file diff --git a/scenes/test_ground.tscn b/scenes/test_ground.tscn index b332434..de31e17 100644 --- a/scenes/test_ground.tscn +++ b/scenes/test_ground.tscn @@ -1,7 +1,9 @@ -[gd_scene load_steps=19 format=3] +[gd_scene load_steps=24 format=3] [ext_resource type="Script" path="res://scripts/gameplay/player.gd" id="1_player"] [ext_resource type="Script" path="res://scripts/ui/debug_overlay.gd" id="2_debug"] +[ext_resource type="Script" path="res://scripts/gameplay/test_ground.gd" id="3_ground"] +[ext_resource type="Script" path="res://scripts/gameplay/npc_placeholder.gd" id="4_imogen"] [sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_sky"] sky_horizon_color = Color(0.64625, 0.65575, 0.67075, 1) @@ -61,7 +63,19 @@ material = SubResource("StandardMaterial3D_player") radius = 0.4 height = 1.8 +[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_imogen"] +albedo_color = Color(0.85, 0.35, 0.5, 1) + +[sub_resource type="CapsuleMesh" id="CapsuleMesh_imogen"] +material = SubResource("StandardMaterial3D_imogen") +radius = 0.4 +height = 1.8 + +[sub_resource type="SphereShape3D" id="SphereShape3D_interact"] +radius = 2.5 + [node name="TestGround" type="Node3D"] +script = ExtResource("3_ground") [node name="WorldEnvironment" type="WorldEnvironment" parent="."] environment = SubResource("Environment_env") @@ -150,6 +164,42 @@ margin = 0.25 [node name="Camera3D" type="Camera3D" parent="Player/CameraPivot/SpringArm3D"] +[node name="Imogen" type="StaticBody3D" parent="."] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 2.5, 0, 2) +script = ExtResource("4_imogen") + +[node name="CollisionShape3D" type="CollisionShape3D" parent="Imogen"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.9, 0) +shape = SubResource("CapsuleShape3D_player") + +[node name="MeshInstance3D" type="MeshInstance3D" parent="Imogen"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.9, 0) +mesh = SubResource("CapsuleMesh_imogen") + +[node name="NameLabel" type="Label3D" parent="Imogen"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 2.2, 0) +billboard = 1 +text = "Imogen" +font_size = 64 +outline_size = 16 + +[node name="PromptLabel" type="Label3D" parent="Imogen"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.8, 0) +visible = false +modulate = Color(1, 0.9, 0.5, 1) +billboard = 1 +text = "E / (A) — Reden" +font_size = 40 +outline_size = 12 + +[node name="InteractionArea" type="Area3D" parent="Imogen"] +collision_layer = 0 +collision_mask = 2 + +[node name="CollisionShape3D" type="CollisionShape3D" parent="Imogen/InteractionArea"] +transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0) +shape = SubResource("SphereShape3D_interact") + [node name="DebugOverlay" type="CanvasLayer" parent="."] script = ExtResource("2_debug") player_path = NodePath("../Player") @@ -157,8 +207,8 @@ player_path = NodePath("../Player") [node name="InfoLabel" type="Label" parent="DebugOverlay"] offset_left = 12.0 offset_top = 8.0 -offset_right = 420.0 -offset_bottom = 128.0 +offset_right = 460.0 +offset_bottom = 240.0 theme_override_colors/font_color = Color(1, 1, 1, 1) theme_override_colors/font_outline_color = Color(0, 0, 0, 1) theme_override_constants/outline_size = 4 diff --git a/scenes/ui/main_menu.tscn b/scenes/ui/main_menu.tscn new file mode 100644 index 0000000..2c5d6e4 --- /dev/null +++ b/scenes/ui/main_menu.tscn @@ -0,0 +1,58 @@ +[gd_scene load_steps=2 format=3] + +[ext_resource type="Script" path="res://scripts/ui/main_menu.gd" id="1_menu"] + +[node name="MainMenu" type="Control"] +layout_mode = 3 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +script = ExtResource("1_menu") + +[node name="Background" type="ColorRect" parent="."] +layout_mode = 1 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +color = Color(0.07, 0.08, 0.1, 1) + +[node name="CenterContainer" type="CenterContainer" parent="."] +layout_mode = 1 +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 + +[node name="VBoxContainer" type="VBoxContainer" parent="CenterContainer"] +layout_mode = 2 +theme_override_constants/separation = 16 + +[node name="TitleLabel" type="Label" parent="CenterContainer/VBoxContainer"] +layout_mode = 2 +theme_override_font_sizes/font_size = 56 +text = "Windgeschworen" +horizontal_alignment = 1 + +[node name="TitleSpacer" type="Control" parent="CenterContainer/VBoxContainer"] +custom_minimum_size = Vector2(0, 24) +layout_mode = 2 + +[node name="StartButton" type="Button" parent="CenterContainer/VBoxContainer"] +custom_minimum_size = Vector2(260, 48) +layout_mode = 2 +text = "Neues Spiel" + +[node name="ContinueButton" type="Button" parent="CenterContainer/VBoxContainer"] +custom_minimum_size = Vector2(260, 48) +layout_mode = 2 +text = "Fortsetzen" + +[node name="QuitButton" type="Button" parent="CenterContainer/VBoxContainer"] +custom_minimum_size = Vector2(260, 48) +layout_mode = 2 +text = "Beenden" diff --git a/scripts/autoloads/game_state.gd b/scripts/autoloads/game_state.gd index c8ad344..9535fcd 100644 --- a/scripts/autoloads/game_state.gd +++ b/scripts/autoloads/game_state.gd @@ -1,7 +1,128 @@ extends Node -## Zentraler Spielzustand (Autoload, SPEC.md Abschnitt 8). +## Zentraler Spielzustand (Autoload, SPEC.md Abschnitte 6 und 8). ## -## Hält ab Phase 1 den Zustand eines Durchlaufs: Spieler-Stats (Kraft, -## Schnelligkeit, Verstand), den Klinge-↔-Herz-Ton-Wert (-100..+100), den -## verdeckten Menschlichkeits-Messwert, den Permadeath-Toggle (Default AN) -## sowie globale Spiel-Flags. Phase 0: leeres Skelett ohne Logik. +## Hält den Zustand eines Durchlaufs: Stats (Kraft/Schnelligkeit/Verstand), +## Klinge-↔-Herz-Ton-Wert, Beziehungswerte pro NPC, den verdeckten +## Menschlichkeits-Messwert und den Permadeath-Toggle. Die Beziehungsdaten +## liegen laut SPEC-Roadmap (Phase 1) hier; RelationshipSystem ist die +## Zugriffs-Fassade darüber. SaveSystem serialisiert den kompletten Zustand +## über to_save_dict()/apply_save_dict(). Startwerte nach SPEC Abschnitt 4: +## solide Kraft und Schnelligkeit, Verstand wächst übers Spiel. + +signal blade_heart_tone_changed(new_tone: int) +signal relationship_changed(npc_id: String, new_value: int) + +const STAT_MIN := 0 +const STAT_MAX := 100 +const TONE_MIN := -100 +const TONE_MAX := 100 +const RELATIONSHIP_MIN := -100 +const RELATIONSHIP_MAX := 100 +const HUMANITY_MIN := -100 +const HUMANITY_MAX := 100 +const DEFAULT_STRENGTH := 35 +const DEFAULT_AGILITY := 35 +const DEFAULT_INTELLECT := 15 + +var strength := DEFAULT_STRENGTH +var agility := DEFAULT_AGILITY +var intellect := DEFAULT_INTELLECT +var blade_heart_tone := 0 +var humanity := 0 +var relationships: Dictionary = {} +var is_permadeath_enabled := true + + +## Setzt alle Werte auf die Startwerte eines neuen Spiels zurück. +func reset() -> void: + strength = DEFAULT_STRENGTH + agility = DEFAULT_AGILITY + intellect = DEFAULT_INTELLECT + blade_heart_tone = 0 + humanity = 0 + relationships.clear() + is_permadeath_enabled = true + blade_heart_tone_changed.emit(blade_heart_tone) + + +## Erhöht einen Stat um amount (negativ = senken) und klemmt ihn auf +## STAT_MIN..STAT_MAX. Gültige Namen: "strength", "agility", "intellect". +func increase_stat(stat_name: String, amount: int) -> void: + match stat_name: + "strength": + strength = clampi(strength + amount, STAT_MIN, STAT_MAX) + "agility": + agility = clampi(agility + amount, STAT_MIN, STAT_MAX) + "intellect": + intellect = clampi(intellect + amount, STAT_MIN, STAT_MAX) + _: + push_warning("Unbekannter Stat: %s" % stat_name) + + +## Verschiebt den Klinge-↔-Herz-Ton-Wert um amount (negativ = Klinge, +## positiv = Herz), klemmt auf TONE_MIN..TONE_MAX und meldet Änderungen +## über blade_heart_tone_changed. +func shift_blade_heart_tone(amount: int) -> void: + var new_tone := clampi(blade_heart_tone + amount, TONE_MIN, TONE_MAX) + if new_tone != blade_heart_tone: + blade_heart_tone = new_tone + blade_heart_tone_changed.emit(blade_heart_tone) + + +## Verschiebt den verdeckten Menschlichkeits-Messwert mit Klemmung. +## Bewusst ohne Signal und ohne UI-Anzeige: in v1 wird der Wert laut SPEC +## nur gesammelt. +func shift_humanity(amount: int) -> void: + humanity = clampi(humanity + amount, HUMANITY_MIN, HUMANITY_MAX) + + +## Liefert den Beziehungswert zur NPC-ID, 0 für unbekannte NPCs. +func get_relationship(npc_id: String) -> int: + return relationships.get(npc_id, 0) + + +## Setzt den Beziehungswert absolut, klemmt auf RELATIONSHIP_MIN..MAX und +## meldet Änderungen über relationship_changed. +func set_relationship(npc_id: String, value: int) -> void: + var new_value := clampi(value, RELATIONSHIP_MIN, RELATIONSHIP_MAX) + if get_relationship(npc_id) != new_value: + relationships[npc_id] = new_value + relationship_changed.emit(npc_id, new_value) + + +## Verschiebt den Beziehungswert relativ um amount (mit Klemmung). +func adjust_relationship(npc_id: String, amount: int) -> void: + set_relationship(npc_id, get_relationship(npc_id) + amount) + + +## Serialisiert den kompletten Zustand als Dictionary für das SaveSystem. +func to_save_dict() -> Dictionary: + return { + "strength": strength, + "agility": agility, + "intellect": intellect, + "blade_heart_tone": blade_heart_tone, + "humanity": humanity, + "relationships": relationships.duplicate(), + "is_permadeath_enabled": is_permadeath_enabled, + } + + +## Stellt den Zustand aus einem Save-Dictionary wieder her. Fehlende +## Schlüssel fallen auf Startwerte zurück, JSON-Zahlen werden auf int +## normalisiert und alle Werte geklemmt; Änderungs-Signale werden nach dem +## Laden ausgelöst. +func apply_save_dict(data: Dictionary) -> void: + strength = clampi(int(data.get("strength", DEFAULT_STRENGTH)), STAT_MIN, STAT_MAX) + agility = clampi(int(data.get("agility", DEFAULT_AGILITY)), STAT_MIN, STAT_MAX) + intellect = clampi(int(data.get("intellect", DEFAULT_INTELLECT)), STAT_MIN, STAT_MAX) + blade_heart_tone = clampi(int(data.get("blade_heart_tone", 0)), TONE_MIN, TONE_MAX) + humanity = clampi(int(data.get("humanity", 0)), HUMANITY_MIN, HUMANITY_MAX) + is_permadeath_enabled = bool(data.get("is_permadeath_enabled", true)) + relationships.clear() + var saved_relationships: Dictionary = data.get("relationships", {}) + for npc_id in saved_relationships: + relationships[String(npc_id)] = clampi(int(saved_relationships[npc_id]), RELATIONSHIP_MIN, RELATIONSHIP_MAX) + blade_heart_tone_changed.emit(blade_heart_tone) + for npc_id in relationships: + relationship_changed.emit(npc_id, relationships[npc_id]) diff --git a/scripts/autoloads/relationship_system.gd b/scripts/autoloads/relationship_system.gd index 3266b93..fbe9968 100644 --- a/scripts/autoloads/relationship_system.gd +++ b/scripts/autoloads/relationship_system.gd @@ -1,7 +1,25 @@ extends Node -## Beziehungswerte pro NPC (Autoload, SPEC.md Abschnitte 6 und 8). +## Zugriffs-Fassade für NPC-Beziehungswerte (Autoload, SPEC.md Abschnitte 6 +## und 8). ## -## Führt ab Phase 4 pro NPC einen Beziehungswert (-100..+100), der durch -## Dialoge und Aktivitäten steigt oder fällt und Reaktionen sowie -## Story-Verzweigungen färbt (z. B. Imogen unter Druck, Wren-Bindung). -## Phase 0: leeres Skelett ohne Logik. +## Die Beziehungsdaten selbst liegen laut SPEC-Roadmap (Phase 1) im +## GameState und werden dort gespeichert und geladen. Gameplay-Code greift +## ausschließlich über diese Fassade zu; ab Phase 2 wächst sie um Logik wie +## Schwellenwerte und Reaktionsstufen. Änderungen meldet +## GameState.relationship_changed. NPC-IDs sind snake_case-Strings, z. B. +## "imogen". + + +## Liefert den Beziehungswert (-100..100) zur NPC-ID, 0 für unbekannte NPCs. +func get_relationship(npc_id: String) -> int: + return GameState.get_relationship(npc_id) + + +## Setzt den Beziehungswert absolut (geklemmt auf -100..100). +func set_relationship(npc_id: String, value: int) -> void: + GameState.set_relationship(npc_id, value) + + +## Verschiebt den Beziehungswert relativ um amount (geklemmt auf -100..100). +func adjust_relationship(npc_id: String, amount: int) -> void: + GameState.adjust_relationship(npc_id, amount) diff --git a/scripts/autoloads/save_system.gd b/scripts/autoloads/save_system.gd index b6f3363..b38be6d 100644 --- a/scripts/autoloads/save_system.gd +++ b/scripts/autoloads/save_system.gd @@ -1,7 +1,50 @@ extends Node -## Speichern und Laden von Spielständen (Autoload, SPEC.md Abschnitte 6 und 8). +## Speichern und Laden von Spielständen (Autoload, SPEC.md Abschnitte 6 +## und 8). ## -## Serialisiert ab Phase 1 den Zustand der übrigen Systeme in Spielstände und -## stellt ihn wieder her. Berücksichtigt später den Permadeath-Modus (Ironman) -## gegenüber dem Story-Modus mit Checkpoints. Phase 0: leeres Skelett ohne -## Logik. +## Serialisiert den kompletten GameState (Stats, Klinge-↔-Herz-Ton-Wert, +## Beziehungen, Menschlichkeit, Permadeath-Flag) als JSON nach user://. +## Die Unterscheidung Ironman vs. Story-Modus mit Checkpoints folgt in einer +## späteren Phase. + +const SAVE_PATH := "user://savegame.json" + + +## Gibt zurück, ob ein Spielstand existiert. +func has_save() -> bool: + return FileAccess.file_exists(SAVE_PATH) + + +## Schreibt den kompletten GameState als JSON nach SAVE_PATH. +## Liefert true bei Erfolg, sonst false mit Fehlermeldung im Log. +func save_game() -> bool: + var file := FileAccess.open(SAVE_PATH, FileAccess.WRITE) + if file == null: + push_error("Spielstand konnte nicht geschrieben werden: %s" % error_string(FileAccess.get_open_error())) + return false + file.store_string(JSON.stringify(GameState.to_save_dict(), "\t")) + file.close() + print("Spielstand gespeichert: %s" % SAVE_PATH) + return true + + +## Lädt den Spielstand aus SAVE_PATH in den GameState. Liefert false, wenn +## keine Datei existiert, sie nicht lesbar ist oder kein gültiges +## JSON-Objekt enthält. +func load_game() -> bool: + if not has_save(): + push_warning("Kein Spielstand vorhanden unter %s" % SAVE_PATH) + return false + var file := FileAccess.open(SAVE_PATH, FileAccess.READ) + if file == null: + push_error("Spielstand konnte nicht geöffnet werden: %s" % error_string(FileAccess.get_open_error())) + return false + var raw_text := file.get_as_text() + file.close() + var parsed: Variant = JSON.parse_string(raw_text) + if not (parsed is Dictionary): + push_error("Spielstand ist beschädigt (kein gültiges JSON-Objekt): %s" % SAVE_PATH) + return false + GameState.apply_save_dict(parsed) + print("Spielstand geladen: %s" % SAVE_PATH) + return true diff --git a/scripts/gameplay/npc_placeholder.gd b/scripts/gameplay/npc_placeholder.gd new file mode 100644 index 0000000..ed8846a --- /dev/null +++ b/scripts/gameplay/npc_placeholder.gd @@ -0,0 +1,60 @@ +extends StaticBody3D +## Platzhalter-NPC für Phase 1a — minimaler Testfall für die +## Beziehungswerte, bewusst ohne das Dialog-System aus Phase 2. +## +## Zeigt in Reichweite (Area3D-Trigger) einen Interaktions-Prompt, gibt bei +## der interact-Action eine fest hinterlegte Zeile in der Godot-Konsole aus +## und erhöht den Beziehungswert der konfigurierten NPC-ID über +## RelationshipSystem um relationship_gain. Ein Cooldown verhindert, dass +## Spam-Interaktion den Wert durchknallt. NPC-ID-Konvention für Phase 2: +## snake_case, z. B. "imogen". + +const INTERACTION_COOLDOWN_MS := 2000 + +@export var npc_id := "imogen" +@export var display_name := "Imogen" +@export var placeholder_line := "Immer noch in einem Stück? Gut. Erspar mir die Sorge, Tyrveil." +@export var relationship_gain := 2 + +var _is_player_in_range := false +var _last_interaction_ms := -INTERACTION_COOLDOWN_MS + +@onready var _prompt_label: Label3D = $PromptLabel +@onready var _interaction_area: Area3D = $InteractionArea + + +## Verbindet die Reichweiten-Signale des Area3D-Triggers. +func _ready() -> void: + _interaction_area.body_entered.connect(_on_body_entered) + _interaction_area.body_exited.connect(_on_body_exited) + + +## Löst die Interaktion aus, wenn der Spieler in Reichweite ist, interact +## gedrückt wird und der Cooldown abgelaufen ist. +func _unhandled_input(event: InputEvent) -> void: + if not _is_player_in_range: + return + if not event.is_action_pressed("interact"): + return + if Time.get_ticks_msec() - _last_interaction_ms < INTERACTION_COOLDOWN_MS: + return + _interact() + + +## Konsolen-Ausgabe als Dialog-Platzhalter plus Beziehungs-Zuwachs. +func _interact() -> void: + _last_interaction_ms = Time.get_ticks_msec() + print("%s: %s" % [display_name, placeholder_line]) + RelationshipSystem.adjust_relationship(npc_id, relationship_gain) + + +## Blendet den Prompt ein, sobald der Spieler die Reichweite betritt. +func _on_body_entered(_body: Node3D) -> void: + _is_player_in_range = true + _prompt_label.visible = true + + +## Blendet den Prompt aus, wenn der Spieler die Reichweite verlässt. +func _on_body_exited(_body: Node3D) -> void: + _is_player_in_range = false + _prompt_label.visible = false diff --git a/scripts/gameplay/test_ground.gd b/scripts/gameplay/test_ground.gd new file mode 100644 index 0000000..d1a422b --- /dev/null +++ b/scripts/gameplay/test_ground.gd @@ -0,0 +1,15 @@ +extends Node3D +## Ablauf-Steuerung der Greybox-Testszene (Phase 1a). +## +## Interims-Lösung, bis Phase 1b den Greybox-Hub mit Schlafsaal-Save +## bringt: Die menu-Action (Tab/Start) speichert den Spielstand über das +## SaveSystem und kehrt ins Hauptmenü zurück. + +const MAIN_MENU_SCENE := "res://scenes/ui/main_menu.tscn" + + +## Speichert bei menu und wechselt zurück ins Hauptmenü. +func _unhandled_input(event: InputEvent) -> void: + if event.is_action_pressed("menu"): + SaveSystem.save_game() + get_tree().change_scene_to_file(MAIN_MENU_SCENE) diff --git a/scripts/ui/debug_overlay.gd b/scripts/ui/debug_overlay.gd index c68e2e2..1daf054 100644 --- a/scripts/ui/debug_overlay.gd +++ b/scripts/ui/debug_overlay.gd @@ -2,11 +2,15 @@ extends CanvasLayer ## Debug-Overlay für Phase 0. ## ## Zeigt FPS, das zuletzt benutzte Eingabegerät (Tastatur/Maus, Xbox- oder -## PS5-Controller), die Spielerposition und die aktuelle Kamera-Distanz an. +## PS5-Controller), die Spielerposition, die aktuelle Kamera-Distanz sowie +## seit Phase 1a die GameState-Werte: Stats, Klinge-↔-Herz-Ton-Wert, +## Beziehungswert zu Imogen und Permadeath-Status. Der verdeckte +## Menschlichkeits-Messwert wird laut SPEC bewusst NICHT angezeigt. ## Die provisorische Geräteerkennung wandert in einer späteren Phase in das ## Autoload InputPrompts (dynamische Button-Prompts, SPEC.md Abschnitt 2). const JOY_MOTION_THRESHOLD := 0.2 +const IMOGEN_NPC_ID := "imogen" const PLAYSTATION_NAME_HINTS: Array[String] = [ "ps5", "ps4", "dualsense", "dualshock", "sony", "playstation", ] @@ -45,6 +49,10 @@ func _process(_delta: float) -> void: lines.append("Position: (%.1f, %.1f, %.1f)" % [pos.x, pos.y, pos.z]) if _player.has_method("get_camera_zoom"): lines.append("Kamera-Zoom: %.1f m" % _player.get_camera_zoom()) + lines.append("Kraft: %d Schnelligkeit: %d Verstand: %d" % [GameState.strength, GameState.agility, GameState.intellect]) + lines.append("Klinge <-> Herz: %+d" % GameState.blade_heart_tone) + lines.append("Beziehung Imogen: %+d" % RelationshipSystem.get_relationship(IMOGEN_NPC_ID)) + lines.append("Permadeath: %s" % ("AN" if GameState.is_permadeath_enabled else "AUS")) _info_label.text = "\n".join(lines) diff --git a/scripts/ui/main_menu.gd b/scripts/ui/main_menu.gd new file mode 100644 index 0000000..9708805 --- /dev/null +++ b/scripts/ui/main_menu.gd @@ -0,0 +1,50 @@ +extends Control +## Minimalistisches Hauptmenü (Phase 1a, SPEC.md Phasen-Roadmap). +## +## Start setzt den GameState auf ein neues Spiel zurück und lädt die +## Greybox-Testszene. Fortsetzen ist nur sichtbar, wenn ein Spielstand +## existiert, und lädt ihn über SaveSystem. Beenden schließt das Spiel. +## Vollständig fokus-navigierbar mit Tastatur und Controller: Die +## confirm-Belegung (Enter/Ⓐ/✕) deckt sich physisch mit Godots ui_accept, +## Pfeiltasten/D-Pad/linker Stick bewegen den Fokus, cancel (Esc/Ⓑ/◯) +## springt auf den Beenden-Button. + +const GAME_SCENE := "res://scenes/test_ground.tscn" + +@onready var _start_button: Button = $CenterContainer/VBoxContainer/StartButton +@onready var _continue_button: Button = $CenterContainer/VBoxContainer/ContinueButton +@onready var _quit_button: Button = $CenterContainer/VBoxContainer/QuitButton + + +## Gibt die Maus frei, blendet Fortsetzen je nach Save-Existenz ein, +## verbindet die Buttons und setzt den Start-Fokus. +func _ready() -> void: + Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) + _continue_button.visible = SaveSystem.has_save() + _start_button.pressed.connect(_on_start_pressed) + _continue_button.pressed.connect(_on_continue_pressed) + _quit_button.pressed.connect(_on_quit_pressed) + _start_button.grab_focus() + + +## Springt mit cancel auf den Beenden-Button. +func _unhandled_input(event: InputEvent) -> void: + if event.is_action_pressed("cancel"): + _quit_button.grab_focus() + + +## Startet ein neues Spiel mit frisch zurückgesetztem GameState. +func _on_start_pressed() -> void: + GameState.reset() + get_tree().change_scene_to_file(GAME_SCENE) + + +## Lädt den Spielstand und wechselt bei Erfolg in die Testszene. +func _on_continue_pressed() -> void: + if SaveSystem.load_game(): + get_tree().change_scene_to_file(GAME_SCENE) + + +## Beendet das Spiel. +func _on_quit_pressed() -> void: + get_tree().quit()