Struct SaveManager 

pub struct SaveManager<S: SaveData> { /* private fields */ }

Manages save/load operations across multiple slots.

S is the game-specific type implementing SaveData.

Implementations

impl<S: SaveData> SaveManager<S>

pub fn new(storage: Box<dyn SaveStorage>) -> Self

Create a new save manager backed by the given storage implementation.

Examples found in repository

examples/hello_dotzuki.rs (line 838)

fn demo_save_load() {
    println!("\n╔══ SAVE / LOAD ═════════════════════════╗");
    let storage = Box::new(InMemoryStorage::new());
    let manager = SaveManager::<GameSave>::new(storage);

    let save = GameSave {
        player_name: "Hero".to_string(),
        player_level: 7,
    };
    manager.save(SaveSlot::Slot1, &save).expect("save");
    let loaded = manager.load(SaveSlot::Slot1).expect("load");
    println!("║ Saved: {:?}", save);
    println!("║ Loaded: {:?}", loaded);
    assert_eq!(save, loaded);
    println!("║ ✓ Round-trip verified");
    println!("╚══════════════════════════════════════════╝");
}

pub fn save(&self, slot: SaveSlot, data: &S) -> Result<(), SaveError>

Save game data to the given slot.

Serializes the data, appends a checksum, and writes to storage.

Examples found in repository

examples/hello_dotzuki.rs (line 844)

fn demo_save_load() {
    println!("\n╔══ SAVE / LOAD ═════════════════════════╗");
    let storage = Box::new(InMemoryStorage::new());
    let manager = SaveManager::<GameSave>::new(storage);

    let save = GameSave {
        player_name: "Hero".to_string(),
        player_level: 7,
    };
    manager.save(SaveSlot::Slot1, &save).expect("save");
    let loaded = manager.load(SaveSlot::Slot1).expect("load");
    println!("║ Saved: {:?}", save);
    println!("║ Loaded: {:?}", loaded);
    assert_eq!(save, loaded);
    println!("║ ✓ Round-trip verified");
    println!("╚══════════════════════════════════════════╝");
}

pub fn load(&self, slot: SaveSlot) -> Result<S, SaveError>

Load game data from the given slot.

Reads from storage, validates the checksum, and deserializes.

Examples found in repository

examples/hello_dotzuki.rs (line 845)

fn demo_save_load() {
    println!("\n╔══ SAVE / LOAD ═════════════════════════╗");
    let storage = Box::new(InMemoryStorage::new());
    let manager = SaveManager::<GameSave>::new(storage);

    let save = GameSave {
        player_name: "Hero".to_string(),
        player_level: 7,
    };
    manager.save(SaveSlot::Slot1, &save).expect("save");
    let loaded = manager.load(SaveSlot::Slot1).expect("load");
    println!("║ Saved: {:?}", save);
    println!("║ Loaded: {:?}", loaded);
    assert_eq!(save, loaded);
    println!("║ ✓ Round-trip verified");
    println!("╚══════════════════════════════════════════╝");
}

pub fn list_slots(&self) -> Vec<(SaveSlot, bool)>

List all slots and whether they contain data.

pub fn delete(&self, slot: SaveSlot) -> Result<(), SaveError>

Delete the save data in the given slot.