Signal-System mit Inky und KV-Store

src/ink.rs

@@ -0,0 +1,95 @@
+//! Dünner Adapter um die `bladeink`-Crate, gekoppelt an unseren `kv::Store`.
+//!
+//! Bei jedem `cont()` läuft ein bidirektionaler Sync:
+//!   - vor `continue`: KV-Werte ins `variables_state` der Story spiegeln
+//!     (Skript sieht aktuelle Spielvariablen)
+//!   - nach `continue`: alle KV-Keys, die das Skript kennt, zurücklesen
+//!     (Ink-`~ var = …`-Writes landen im KV)
+//!
+//! Variablen die der KV kennt, das Skript aber nicht als `VAR` deklariert,
+//! lehnt bladeink beim `set_variable` ab — wir ignorieren das still.
+//! Variablen die nur im Skript existieren, werden beim Read-Back ignoriert
+//! (KV bleibt minimal: nur was Rust kennt).
+
+use std::fs::read_to_string;
+
+use bladeink::story::Story as BladeStory;
+
+use crate::kv::Store;
+
+pub enum StoryState {
+    Text(String),
+    Choice { prompt: String, options: Vec<String> },
+    End,
+}
+
+pub struct Story {
+    inner: BladeStory,
+    tags:  Vec<String>,
+}
+
+impl Story {
+    pub fn load(path: &str, kv: &Store) -> Self {
+        let src = read_to_string(path)
+            .unwrap_or_else(|e| panic!("ink load {}: {}", path, e));
+        let inner = BladeStory::new(&src)
+            .unwrap_or_else(|e| panic!("ink parse {}: {:?}", path, e));
+        let mut s = Self { inner, tags: Vec::new() };
+        s.sync_from_kv(kv);
+        s
+    }
+
+    pub fn take_tags(&mut self) -> Vec<String> { std::mem::take(&mut self.tags) }
+
+    pub fn cont(&mut self, kv: &mut Store) -> StoryState {
+        self.sync_from_kv(kv);
+
+        // continue_maximally ruft intern reset_output() vor jedem cont() —
+        // damit überschriebe der Tag der letzten Zeile alle vorherigen.
+        // Wir loopen selbst und sammeln Tags nach jedem Schritt ein, sonst
+        // gehen z.B. `# set has_key true` am Knoten-Anfang bei mehrzeiligem
+        // Text verloren.
+        let mut text = String::new();
+        while self.inner.can_continue() {
+            let chunk = self.inner.cont()
+                .unwrap_or_else(|e| panic!("ink cont: {:?}", e));
+            text.push_str(&chunk);
+            if let Ok(t) = self.inner.get_current_tags() {
+                self.tags.extend(t);
+            }
+        }
+        let text = text.trim().to_string();
+
+        self.sync_to_kv(kv);
+
+        let choices = self.inner.get_current_choices();
+        if !choices.is_empty() {
+            let options = choices.iter().map(|c| c.text.clone()).collect();
+            return StoryState::Choice { prompt: text, options };
+        }
+        if !text.is_empty() { return StoryState::Text(text); }
+        StoryState::End
+    }
+
+    pub fn choose(&mut self, i: usize) {
+        self.inner.choose_choice_index(i)
+            .unwrap_or_else(|e| panic!("ink choose {}: {:?}", i, e));
+    }
+
+    fn sync_from_kv(&mut self, kv: &Store) {
+        for (name, value) in kv {
+            // set_variable schlägt fehl wenn der Name kein deklariertes
+            // VAR im Skript ist — still ignorieren.
+            let _ = self.inner.set_variable(name, value);
+        }
+    }
+
+    fn sync_to_kv(&self, kv: &mut Store) {
+        let keys: Vec<String> = kv.keys().cloned().collect();
+        for name in keys {
+            if let Some(v) = self.inner.get_variable(&name) {
+                kv.insert(name, v);
+            }
+        }
+    }
+}