moonshine-save 0.7.0

Save/Load framework for Bevy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::fs;

use bevy::prelude::*;
use bevy_ecs::system::RunSystemOnce;
use moonshine_save::prelude::*;

const SAVE_PATH: &str = "test_basic.ron";

#[derive(Bundle)]
struct FooBundle {
    foo: Foo,
    bar: FooBar,
    save: Save,
}

#[derive(Bundle, Default)]
struct BarBundle {
    bar: Bar,
    save: Save,
}

#[derive(Component, Default, Reflect)]
#[reflect(Component)]
#[require(Save)]
struct Foo(u32);

#[derive(Component, Default, Reflect)]
#[reflect(Component)]
#[require(Save)]
struct Bar;

#[derive(Component, MapEntities, Reflect)]
#[reflect(Component, MapEntities)]
struct FooBar(#[entities] Entity);

impl FromWorld for FooBar {
    fn from_world(_: &mut World) -> Self {
        Self(Entity::PLACEHOLDER)
    }
}

fn app() -> App {
    let mut app = App::new();
    app.register_type::<Foo>()
        .register_type::<FooBar>()
        .register_type::<Bar>()
        .add_plugins((MinimalPlugins, AssetPlugin::default()));
    app
}

#[test]
fn main() {
    {
        let mut app = app();
        app.add_observer(save_on_default_event);

        let bar = app
            .world_mut()
            .run_system_once(|mut commands: Commands| {
                // Spawn some entities
                let bar = commands.spawn(BarBundle::default()).id();
                commands.spawn(FooBundle {
                    foo: Foo(42),
                    bar: FooBar(bar),
                    save: Save,
                });

                // Save
                commands.trigger_save(SaveWorld::default_into_file(SAVE_PATH));

                bar
            })
            .unwrap();

        // Check pre-conditions
        let world = app.world_mut();
        assert_eq!(world.query::<&Foo>().single(world).unwrap().0, 42);
        assert_eq!(world.query::<&FooBar>().single(world).unwrap().0, bar);
        assert!(world.entity(bar).contains::<Save>());

        // Ensure file was written to disk
        assert!(fs::read(SAVE_PATH).is_ok());
    }

    {
        let mut app = app();
        app.add_observer(load_on_default_event);

        let _ = app.world_mut().run_system_once(|mut commands: Commands| {
            // Spawn an entity to offset indices
            commands.spawn_empty();

            // Load
            commands.trigger_load(LoadWorld::default_from_file(SAVE_PATH));
        });

        let world = app.world_mut();
        let bar = world
            .query_filtered::<Entity, With<Bar>>()
            .single(world)
            .unwrap();

        assert_eq!(world.query::<&Foo>().single(world).unwrap().0, 42);
        assert_eq!(world.query::<&FooBar>().single(world).unwrap().0, bar);
        assert!(world.entity(bar).contains::<Save>());

        fs::remove_file(SAVE_PATH).unwrap();
    }
}