godot-bevy 0.9.2

Bridge between Bevy ECS and Godot 4 for Rust-powered game development
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#[cfg(test)]
mod tests {
    use crate::plugins::collisions::Collisions;
    use crate::plugins::scene_tree::Groups;
    use crate::plugins::transforms::{
        GodotTransformConfig, TransformSyncMetadata, TransformSyncMode,
    };
    use bevy::reflect::{Reflect, ReflectRef, TypeRegistry};

    #[test]
    fn test_collisions_reflection() {
        // Test type registration
        let mut registry = TypeRegistry::default();
        registry.register::<Collisions>();

        // Verify the type is registered
        assert!(
            registry
                .get_type_info(std::any::TypeId::of::<Collisions>())
                .is_some()
        );

        // Test reflection capabilities
        let collisions = Collisions::default();
        let reflected = collisions.as_reflect();

        // Verify we can get the reflect info
        let type_info = reflected.get_represented_type_info().unwrap();
        assert!(type_info.type_path().contains("Collisions"));

        // Test struct reflection
        if let ReflectRef::Struct(struct_ref) = reflected.reflect_ref() {
            // Check fields exist
            assert_eq!(struct_ref.field_len(), 2);
            assert!(struct_ref.field("colliding_entities").is_some());
            assert!(struct_ref.field("recent_collisions").is_some());
        } else {
            panic!("Expected Struct reflection");
        }

        // Test cloning via reflection
        let _cloned = reflected.reflect_clone();
    }

    #[test]
    fn test_groups_reflection() {
        let mut registry = TypeRegistry::default();
        registry.register::<Groups>();

        assert!(
            registry
                .get_type_info(std::any::TypeId::of::<Groups>())
                .is_some()
        );

        // Can't easily create Groups without Godot node, but we can test the type is reflectable
        // The actual reflection would work at runtime
    }

    #[test]
    fn test_transform_config_reflection() {
        let mut registry = TypeRegistry::default();
        registry.register::<GodotTransformConfig>();
        registry.register::<TransformSyncMode>();

        assert!(
            registry
                .get_type_info(std::any::TypeId::of::<GodotTransformConfig>())
                .is_some()
        );
        assert!(
            registry
                .get_type_info(std::any::TypeId::of::<TransformSyncMode>())
                .is_some()
        );

        let config = GodotTransformConfig::default();
        let reflected = config.as_reflect();

        // Check type info
        let type_info = reflected.get_represented_type_info().unwrap();
        assert!(type_info.type_path().contains("GodotTransformConfig"));

        // Check struct fields
        if let ReflectRef::Struct(struct_ref) = reflected.reflect_ref() {
            assert!(struct_ref.field("sync_mode").is_some());
        } else {
            panic!("Expected Struct reflection");
        }

        // Test enum reflection
        let mode = TransformSyncMode::TwoWay;
        let mode_reflected = mode.as_reflect();
        let mode_info = mode_reflected.get_represented_type_info().unwrap();
        assert!(mode_info.type_path().contains("TransformSyncMode"));
    }

    #[test]
    fn test_scene_tree_config_reflection() {
        use crate::plugins::scene_tree::SceneTreeConfig;

        let mut registry = TypeRegistry::default();
        registry.register::<SceneTreeConfig>();

        assert!(
            registry
                .get_type_info(std::any::TypeId::of::<SceneTreeConfig>())
                .is_some()
        );

        let config = SceneTreeConfig {
            add_child_relationship: false,
        };
        let reflected = config.as_reflect();

        // Check type info
        let type_info = reflected.get_represented_type_info().unwrap();
        assert!(type_info.type_path().contains("SceneTreeConfig"));

        // Check struct fields
        if let ReflectRef::Struct(struct_ref) = reflected.reflect_ref() {
            assert!(struct_ref.field("add_child_relationship").is_some());
        } else {
            panic!("Expected Struct reflection");
        }
    }

    #[test]
    fn test_transform_sync_metadata_reflection() {
        let mut registry = TypeRegistry::default();
        registry.register::<TransformSyncMetadata>();

        assert!(
            registry
                .get_type_info(std::any::TypeId::of::<TransformSyncMetadata>())
                .is_some()
        );

        let metadata = TransformSyncMetadata::default();
        let reflected = metadata.as_reflect();

        // Check type info
        let type_info = reflected.get_represented_type_info().unwrap();
        assert!(type_info.type_path().contains("TransformSyncMetadata"));

        // Since last_sync_tick is marked with #[reflect(ignore)], it won't be accessible
        // through reflection, but the struct itself is still reflectable
        if let ReflectRef::Struct(struct_ref) = reflected.reflect_ref() {
            // The field is ignored, so field_len should be 0
            assert_eq!(struct_ref.field_len(), 0);
            // And the field should not be accessible
            assert!(struct_ref.field("last_sync_tick").is_none());
        } else {
            panic!("Expected Struct reflection");
        }
    }
}