centralized state

2026-06-13 13:44:02 +02:00
parent 0a8861a5b1
commit 48c499e356
11 changed files with 693 additions and 206 deletions
@@ -0,0 +1,228 @@
+//! Session: der geteilte Anwendungszustand über allen Frontends.
+//!
+//! Es existiert genau eine `Session` pro Lauf. CLI und Fenster steuern
+//! dieselbe — das Fenster besitzt sie, die Terminal-Eingabe schickt nur
+//! Befehlszeilen hinein. Dadurch kann es keinen Mismatch geben: ein
+//! `Game`-Zustand, ein `Mode`, beide Frontends stellen ihn nur dar.
+//!
+//! Schicht: `engine ← session ← { cli, render }`. Die Session kennt kein
+//! Frontend — `exec` nimmt eine Befehlszeile und *gibt* Ausgabezeilen
+//! zurück (statt zu drucken), damit jedes Frontend sie frei darstellt
+//! (Terminal jetzt, In-Fenster-Konsole später).
+
+use crate::engine::game::{Action, Game};
+use crate::engine::ink::StoryState;
+use crate::engine::{kv, signals, story_ctrl};
+
+/// Was die Frontends gerade darstellen sollen. Geteilt, damit CLI und GUI
+/// nie uneins sind, ob ein Dialog läuft.
+pub enum Mode {
+    /// Freie Welt — das Fenster rendert die Szene, die Konsole nimmt
+    /// Engine-Befehle.
+    Free,
+    /// Ein Dialog läuft — das Fenster pausiert die Welt und zeigt (sobald
+    /// Text-Rendering existiert) Panels; Eingaben treiben den Dialog statt
+    /// Befehle.
+    Dialog(Dialog),
+}
+
+/// Aktueller Dialogschritt, frontend-neutral. `choices` leer = reiner Text,
+/// der auf „weiter" (Leerzeile/Enter) wartet.
+pub struct Dialog {
+    // Wird vom Panel-Renderer der UI-Phase gelesen; bis dahin läuft der
+    // Dialogtext über die Konsolen-Ausgabe (siehe `step`).
+    #[allow(dead_code)]
+    pub text:    String,
+    pub choices: Vec<String>,
+}
+
+pub struct Session {
+    pub game: Game,
+    pub mode: Mode,
+    signals_path: String,
+}
+
+/// Ergebnis einer Eingabezeile: Ausgabezeilen plus, ob das Frontend
+/// beenden soll (`quit`/`exit`).
+pub struct ExecResult {
+    pub output: Vec<String>,
+    pub quit:   bool,
+}
+
+impl ExecResult {
+    fn lines(output: Vec<String>) -> Self { Self { output, quit: false } }
+    fn empty() -> Self { Self { output: Vec::new(), quit: false } }
+}
+
+impl Session {
+    pub fn new(signals_path: String) -> Self {
+        let game = Game::new(signals::load_signals(&signals_path));
+        Self { game, mode: Mode::Free, signals_path }
+    }
+
+    /// Reserviertes `[init]`-Signal feuern (KV-Defaults, bevor etwas läuft).
+    /// Eigene Methode statt im Konstruktor, damit das Frontend die Ausgabe
+    /// darstellen kann — und damit `init` bereits einen Dialog öffnen darf.
+    pub fn start(&mut self) -> Vec<String> {
+        self.fire("init", None)
+    }
+
+    /// Eine Eingabezeile verarbeiten. Im Dialog treibt sie den Dialog,
+    /// sonst ist sie ein Engine-Befehl. Dieselbe Eingabequelle, je nach
+    /// `mode` unterschiedlich gedeutet — so steuert Terminal *und* (später)
+    /// Klick denselben Dialog ohne Sonderpfad.
+    pub fn exec(&mut self, line: &str) -> ExecResult {
+        match self.mode {
+            Mode::Dialog(_) => self.dialog_input(line),
+            Mode::Free      => self.command(line),
+        }
+    }
+
+    fn command(&mut self, line: &str) -> ExecResult {
+        let line = line.trim();
+        match line {
+            "" => ExecResult::empty(),
+            "quit" | "exit" => ExecResult { output: Vec::new(), quit: true },
+            "help" => ExecResult::lines(help()),
+            "kv"   => ExecResult::lines(self.dump_kv()),
+            "reload" => {
+                self.game.signals = signals::load_signals(&self.signals_path);
+                ExecResult::lines(vec![
+                    format!("{} Signale geladen.", self.game.signals.len()),
+                ])
+            }
+            _ => {
+                if let Some(sig) = line.strip_prefix("signal ") {
+                    ExecResult::lines(self.fire(sig.trim(), None))
+                } else if let Some(name) = line.strip_prefix("use ") {
+                    // Objekt-Interaktion simulieren: Signal ist der gestrippte
+                    // Name, $self der volle — wie der LMB-Klick-Pfad in irl3d.
+                    let name = name.trim();
+                    let key = signals::signal_key(name).to_string();
+                    ExecResult::lines(self.fire(&key, Some(name.to_string())))
+                } else {
+                    ExecResult::lines(vec![
+                        format!("unbekannter Befehl: {line:?} — `help` für Befehle"),
+                    ])
+                }
+            }
+        }
+    }
+
+    fn dialog_input(&mut self, line: &str) -> ExecResult {
+        let Mode::Dialog(d) = &self.mode else { return ExecResult::empty(); };
+        let sel = if d.choices.is_empty() {
+            None // reiner Text → Leerzeile/Enter blättert weiter
+        } else {
+            match line.trim().parse::<usize>() {
+                Ok(n) if (1..=d.choices.len()).contains(&n) => Some(n - 1),
+                _ => return ExecResult::lines(vec![format!("  (1..{})", d.choices.len())]),
+            }
+        };
+        ExecResult::lines(self.step(sel))
+    }
+
+    /// Signal dispatchen, deferred Actions einsammeln und — falls dadurch
+    /// eine Story startete — den ersten Dialogschritt ziehen.
+    fn fire(&mut self, signal: &str, instance: Option<String>) -> Vec<String> {
+        {
+            let mut ctx = self.game.action_ctx(instance);
+            signals::dispatch(signal, &mut ctx);
+        }
+        let mut out = self.drain_actions();
+        if self.game.story.is_some() {
+            out.extend(self.step(None));
+        }
+        out
+    }
+
+    /// Einen Story-Schritt treiben und `mode` daran anpassen. `sel` ist die
+    /// Choice-Auswahl bzw. `None` für ersten Schritt / Text-Weiterblättern.
+    /// Tags gehen wie gehabt zurück in den Dispatcher (siehe story_ctrl).
+    fn step(&mut self, sel: Option<usize>) -> Vec<String> {
+        let state = {
+            let mut ctx = self.game.action_ctx(None);
+            let (state, tags) = story_ctrl::advance(sel, &mut ctx);
+            for t in &tags { signals::dispatch(t, &mut ctx); }
+            state
+        };
+        let mut out = self.drain_actions();
+        match state {
+            None | Some(StoryState::End) => {
+                self.mode = Mode::Free;
+            }
+            Some(StoryState::Text(text)) => {
+                out.push(text.clone());
+                self.mode = Mode::Dialog(Dialog { text, choices: Vec::new() });
+            }
+            Some(StoryState::Choice { prompt, options }) => {
+                if !prompt.is_empty() { out.push(prompt.clone()); }
+                for (i, o) in options.iter().enumerate() {
+                    out.push(format!("  {}) {o}", i + 1));
+                }
+                self.mode = Mode::Dialog(Dialog { text: prompt, choices: options });
+            }
+        }
+        out
+    }
+
+    fn drain_actions(&mut self) -> Vec<String> {
+        self.game.actions.drain(..).map(|a| match a {
+            Action::HideObject(n) => format!("[action] hide_object {n}"),
+            Action::PlaySound(n)  => format!("[action] play_sound {n}"),
+        }).collect()
+    }
+
+    fn dump_kv(&self) -> Vec<String> {
+        let mut keys: Vec<&String> = self.game.kv.keys().collect();
+        keys.sort();
+        keys.into_iter()
+            .map(|k| format!("  {k} = {}", kv::format_value(&self.game.kv[k])))
+            .collect()
+    }
+}
+
+fn help() -> Vec<String> {
+    vec![
+        "  signal <s>        Signal feuern oder Action direkt ausführen".into(),
+        "                    (z.B. `signal Cube`, `signal set has_key true`)".into(),
+        "  use <instance>    Objekt-Interaktion simulieren — `use Mushroom.005`".into(),
+        "                    feuert Signal `Mushroom` mit $self = Mushroom.005".into(),
+        "  kv                KV-Store anzeigen".into(),
+        "  reload            signals.toml neu laden".into(),
+        "  quit              beenden".into(),
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Fehlender Pfad → leere Signal-Table (load_signals schluckt den Fehler),
+    // also keine Asset-Abhängigkeit für diese Tests.
+    fn empty_session() -> Session { Session::new("/nonexistent/signals.toml".into()) }
+
+    #[test]
+    fn quit_sets_flag() {
+        let mut s = empty_session();
+        assert!(s.exec("quit").quit);
+    }
+
+    #[test]
+    fn builtin_command_mutates_kv_and_stays_free() {
+        let mut s = empty_session();
+        // Unbekanntes Signal fällt auf den Builtin-Pfad durch → `set`.
+        let r = s.exec("signal set has_key true");
+        assert!(!r.quit);
+        assert!(s.game.kv["has_key"].coerce_to_bool().unwrap());
+        assert!(matches!(s.mode, Mode::Free));
+    }
+
+    #[test]
+    fn unknown_command_reports_and_stays_free() {
+        let mut s = empty_session();
+        let r = s.exec("frobnicate");
+        assert_eq!(r.output.len(), 1);
+        assert!(matches!(s.mode, Mode::Free));
+    }
+}