bevy_enum_filter 0.3.0

Filter by enum variant in Bevy queries
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

#![doc = include_str!("../README.md")]

mod extensions;
mod filter_trait;
mod systems;

pub use bevy_enum_filter_derive::{Enum, EnumFilter};
pub use filter_trait::EnumFilter;
pub use systems::watch_for_enum;

pub mod prelude {
    pub use super::extensions::AddEnumFilter;
    pub use super::filter_trait::EnumFilter;
    pub use bevy_enum_filter_derive::{Enum, EnumFilter};
}

#[cfg(test)]
mod tests {
    use super::prelude::*;
    use bevy::prelude::*;

    #[derive(Component, EnumFilter)]
    enum TestEnum {
        Unit,
        Tuple(usize),
        Struct { _foo: usize },
    }

    #[test]
    fn should_use_enum_filter() {
        #[derive(Event)]
        struct FoundFilter(bool);

        let mut app = App::new();
        app.add_enum_filter::<TestEnum>();
        app.add_event::<FoundFilter>();
        app.add_systems(Update, remove_entity_with_enum);

        let entity = app.world.spawn_empty().id();

        app.update();

        assert!(app.world.get_entity(entity).is_some());

        app.world
            .entity_mut(entity)
            .insert(TestEnum::Struct { _foo: 123 });

        app.update();
        app.update();

        assert!(app.world.get_entity(entity).is_none());

        fn remove_entity_with_enum(
            query: Query<Entity, With<Enum!(TestEnum::Struct)>>,
            mut commands: Commands,
        ) {
            for entity in &query {
                commands.entity(entity).despawn();
            }
        }
    }

    #[test]
    fn should_automatically_handle_markers() {
        let mut app = App::new();
        app.add_enum_filter::<TestEnum>();
        let entity = app.world.spawn_empty().id();

        app.update();

        let total_components = app.world.entity(entity).archetype().components().count();
        assert_eq!(0, total_components);
        assert!(!app
            .world
            .entity(entity)
            .contains::<test_enum_filters::Tuple>());

        app.world.entity_mut(entity).insert(TestEnum::Tuple(123));

        app.update();

        let total_components = app.world.entity(entity).archetype().components().count();
        assert_eq!(2, total_components);
        assert!(app
            .world
            .entity(entity)
            .contains::<test_enum_filters::Tuple>());

        app.world.entity_mut(entity).insert(TestEnum::Unit);

        app.update();

        let total_components = app.world.entity(entity).archetype().components().count();
        assert_eq!(2, total_components);
        assert!(!app
            .world
            .entity(entity)
            .contains::<test_enum_filters::Tuple>());
        assert!(app
            .world
            .entity(entity)
            .contains::<test_enum_filters::Unit>());
    }
}