103 lines
3.5 KiB
Rust
103 lines
3.5 KiB
Rust
//! Persistenter Game-State Key-Value-Store.
|
|
//!
|
|
//! Single Source of Truth für alle Spielvariablen (Quest-Flags, Inventar-
|
|
//! Counter, Story-Beats). Ink-Skripte haben eigene `variables_state`-Stores;
|
|
//! die werden bei jedem `cont()` mit diesem KV synchronisiert (siehe
|
|
//! [`crate::engine::ink`]). Damit der KV authoritativ bleibt: externe Actions
|
|
//! (`set`, `inc`, `clear`) ändern *immer* den KV, niemals direkt die Story.
|
|
//!
|
|
//! Wir nutzen `bladeink::ValueType` als Value, damit die Sync-Konvertierung
|
|
//! gratis ist (kein Mapping zwischen Rust- und Ink-Typen nötig).
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use bladeink::value_type::ValueType;
|
|
|
|
pub type Store = HashMap<String, ValueType>;
|
|
|
|
/// Parst einen Action-Arg-String zu einem `ValueType`. Reihenfolge:
|
|
/// `true`/`false` → Bool, dann i32, dann f32, sonst String.
|
|
pub fn parse_value(s: &str) -> ValueType {
|
|
let s = s.trim();
|
|
match s {
|
|
"true" => return ValueType::Bool(true),
|
|
"false" => return ValueType::Bool(false),
|
|
_ => {}
|
|
}
|
|
if let Ok(i) = s.parse::<i32>() { return ValueType::Int(i); }
|
|
if let Ok(f) = s.parse::<f32>() { return ValueType::Float(f); }
|
|
ValueType::new(s)
|
|
}
|
|
|
|
/// Menschenlesbare Darstellung für REPL-Dumps und Debug-Logs.
|
|
pub fn format_value(v: &ValueType) -> String {
|
|
match v {
|
|
ValueType::Bool(b) => b.to_string(),
|
|
ValueType::Int(i) => i.to_string(),
|
|
ValueType::Float(f) => f.to_string(),
|
|
other => other.coerce_to_string().unwrap_or_else(|_| "<?>".into()),
|
|
}
|
|
}
|
|
|
|
pub fn apply_set(args: &str, store: &mut Store) {
|
|
let Some((name, value)) = args.split_once(char::is_whitespace) else {
|
|
eprintln!("[kv] set: expected 'name value', got {:?}", args);
|
|
return;
|
|
};
|
|
store.insert(name.trim().to_string(), parse_value(value));
|
|
}
|
|
|
|
pub fn apply_inc(args: &str, store: &mut Store) {
|
|
let (name, delta) = args.split_once(char::is_whitespace).unwrap_or((args, "1"));
|
|
let name = name.trim();
|
|
let delta = delta.trim().parse::<i32>().unwrap_or(1);
|
|
let cur = store.get(name).and_then(|v| v.coerce_to_int().ok()).unwrap_or(0);
|
|
store.insert(name.to_string(), ValueType::Int(cur + delta));
|
|
}
|
|
|
|
pub fn apply_clear(args: &str, store: &mut Store) {
|
|
store.remove(args.trim());
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parse_value_types() {
|
|
assert!(matches!(parse_value("true"), ValueType::Bool(true)));
|
|
assert!(matches!(parse_value("false"), ValueType::Bool(false)));
|
|
assert!(matches!(parse_value("42"), ValueType::Int(42)));
|
|
assert!(matches!(parse_value("-7"), ValueType::Int(-7)));
|
|
assert!(matches!(parse_value("1.5"), ValueType::Float(f) if f == 1.5));
|
|
assert!(matches!(parse_value("hallo"), ValueType::String(_)));
|
|
}
|
|
|
|
#[test]
|
|
fn set_inc_clear_roundtrip() {
|
|
let mut s = Store::new();
|
|
apply_set("clicks 3", &mut s);
|
|
assert_eq!(s["clicks"].coerce_to_int().unwrap(), 3);
|
|
|
|
apply_inc("clicks", &mut s);
|
|
assert_eq!(s["clicks"].coerce_to_int().unwrap(), 4);
|
|
|
|
apply_inc("clicks -2", &mut s);
|
|
assert_eq!(s["clicks"].coerce_to_int().unwrap(), 2);
|
|
|
|
// inc auf unbekannten Key startet bei 0
|
|
apply_inc("fresh 5", &mut s);
|
|
assert_eq!(s["fresh"].coerce_to_int().unwrap(), 5);
|
|
|
|
apply_clear("clicks", &mut s);
|
|
assert!(!s.contains_key("clicks"));
|
|
}
|
|
|
|
#[test]
|
|
fn set_without_value_is_noop() {
|
|
let mut s = Store::new();
|
|
apply_set("only_name", &mut s);
|
|
assert!(s.is_empty());
|
|
}
|
|
}
|