Migrate to bevy 0.16

Author: Wcubed

integration_tests/src/how_to_test_apps.rs

@@ -1,3 +1,4 @@
+#![cfg(test)]
 //! Demonstrates simple integration testing of Bevy applications.
 //!
 //! By substituting [`DefaultPlugins`] with [`MinimalPlugins`], Bevy can run completely headless.

integration_tests/src/how_to_test_systems.rs

@@ -7,13 +7,14 @@ struct Enemy {
     score_value: u32,
 }
 
+#[derive(Event)]
 struct EnemyDied(u32);
 
 #[derive(Resource)]
 struct Score(u32);
 
 fn update_score(mut dead_enemies: EventReader<EnemyDied>, mut score: ResMut<Score>) {
-    for value in dead_enemies.iter() {
+    for value in dead_enemies.read() {
         score.0 += value.0;
     }
 }
@@ -37,7 +38,7 @@ fn hurt_enemies(mut enemies: Query<&mut Enemy>) {
     }
 }
 
-fn spawn_enemy(mut commands: Commands, keyboard_input: Res<Input<KeyCode>>) {
+fn spawn_enemy(mut commands: Commands, keyboard_input: Res<ButtonInput<KeyCode>>) {
     if keyboard_input.just_pressed(KeyCode::Space) {
         commands.spawn(Enemy {
             hit_points: 5,
@@ -58,11 +59,11 @@ fn did_hurt_enemy() {
     app.add_event::<EnemyDied>();
 
     // Add our two systems
-    app.add_systems((hurt_enemies, despawn_dead_enemies).chain());
+    app.add_systems(Update, (hurt_enemies, despawn_dead_enemies).chain());
 
     // Setup test entities
     let enemy_id = app
-        .world
+        .world_mut()
         .spawn(Enemy {
             hit_points: 5,
             score_value: 3,
@@ -73,8 +74,8 @@ fn did_hurt_enemy() {
     app.update();
 
     // Check resulting changes
-    assert!(app.world.get::<Enemy>(enemy_id).is_some());
-    assert_eq!(app.world.get::<Enemy>(enemy_id).unwrap().hit_points, 4);
+    assert!(app.world().get::<Enemy>(enemy_id).is_some());
+    assert_eq!(app.world().get::<Enemy>(enemy_id).unwrap().hit_points, 4);
 }
 
 #[test]
@@ -89,11 +90,11 @@ fn did_despawn_enemy() {
     app.add_event::<EnemyDied>();
 
     // Add our two systems
-    app.add_systems((hurt_enemies, despawn_dead_enemies).chain());
+    app.add_systems(Update, (hurt_enemies, despawn_dead_enemies).chain());
 
     // Setup test entities
     let enemy_id = app
-        .world
+        .world_mut()
         .spawn(Enemy {
             hit_points: 1,
             score_value: 1,
@@ -104,12 +105,12 @@ fn did_despawn_enemy() {
     app.update();
 
     // Check enemy was despawned
-    assert!(app.world.get::<Enemy>(enemy_id).is_none());
+    assert!(app.world().get::<Enemy>(enemy_id).is_none());
 
     // Get `EnemyDied` event reader
-    let enemy_died_events = app.world.resource::<Events<EnemyDied>>();
-    let mut enemy_died_reader = enemy_died_events.get_reader();
-    let enemy_died = enemy_died_reader.iter(enemy_died_events).next().unwrap();
+    let enemy_died_events = app.world().resource::<Events<EnemyDied>>();
+    let mut enemy_died_cursor = enemy_died_events.get_cursor();
+    let enemy_died = enemy_died_cursor.read(enemy_died_events).next().unwrap();
 
     // Check the event has been sent
     assert_eq!(enemy_died.0, 1);
@@ -121,27 +122,35 @@ fn spawn_enemy_using_input_resource() {
     let mut app = App::new();
 
     // Add our systems
-    app.add_system(spawn_enemy);
+    app.add_systems(Update, spawn_enemy);
 
     // Setup test resource
-    let mut input = Input::<KeyCode>::default();
+    let mut input = ButtonInput::<KeyCode>::default();
     input.press(KeyCode::Space);
     app.insert_resource(input);
 
     // Run systems
     app.update();
 
     // Check resulting changes, one entity has been spawned with `Enemy` component
-    assert_eq!(app.world.query::<&Enemy>().iter(&app.world).len(), 1);
+    assert_eq!(
+        app.world_mut().query::<&Enemy>().iter(&app.world()).len(),
+        1
+    );
 
     // Clear the `just_pressed` status for all `KeyCode`s
-    app.world.resource_mut::<Input<KeyCode>>().clear();
+    app.world_mut()
+        .resource_mut::<ButtonInput<KeyCode>>()
+        .clear();
 
     // Run systems
     app.update();
 
     // Check resulting changes, no new entity has been spawned
-    assert_eq!(app.world.query::<&Enemy>().iter(&app.world).len(), 1);
+    assert_eq!(
+        app.world_mut().query::<&Enemy>().iter(&app.world()).len(),
+        1
+    );
 }
 
 #[test]
@@ -156,16 +165,16 @@ fn update_score_on_event() {
     app.add_event::<EnemyDied>();
 
     // Add our systems
-    app.add_system(update_score);
+    app.add_systems(Update, update_score);
 
     // Send an `EnemyDied` event
-    app.world
+    app.world_mut()
         .resource_mut::<Events<EnemyDied>>()
         .send(EnemyDied(3));
 
     // Run systems
     app.update();
 
     // Check resulting changes
-    assert_eq!(app.world.resource::<Score>().0, 3);
+    assert_eq!(app.world().resource::<Score>().0, 3);
 }

integration_tests/src/scenes/components.rs

@@ -1,10 +1,11 @@
 #![cfg(test)]
 //! Testing of serialization and deserialization of diverse scene components.
 
-use bevy::ecs::entity::EntityMap;
+use bevy::ecs::entity::EntityHashMap;
 use bevy::prelude::*;
 use bevy::reflect::erased_serde::__private::serde::de::DeserializeSeed;
 use bevy::reflect::erased_serde::__private::serde::Serialize;
+use bevy::reflect::TypeRegistry;
 use bevy::scene::serde::{SceneDeserializer, SceneSerializer};
 use bevy::scene::ScenePlugin;
 use bincode::Options;
@@ -32,43 +33,43 @@ fn messagepack_roundtrip_equality() {
 
 /// Convenience function for testing the roundtrip equality of different serialization methods.
 fn assert_round_trip_equality(
-    serialize: fn(DynamicScene, &AppTypeRegistry) -> Vec<u8>,
+    serialize: fn(DynamicScene, &TypeRegistry) -> Vec<u8>,
     deserialize: fn(SceneDeserializer, &[u8]) -> DynamicScene,
 ) {
     let mut input_app = create_test_app();
     spawn_test_entities(&mut input_app);
 
-    let type_registry = input_app.world.resource::<AppTypeRegistry>();
-    let scene = DynamicScene::from_world(&input_app.world, type_registry);
-    let serialized = serialize(scene, type_registry);
+    let type_registry = input_app.world().resource::<AppTypeRegistry>().read();
+    let scene = DynamicScene::from_world(&input_app.world());
+    let serialized = serialize(scene, &type_registry);
 
     // We use a clean app to deserialize into, so nothing of the input app can interfere.
     let mut output_app = create_test_app();
     let scene = {
         let scene_deserializer = SceneDeserializer {
-            type_registry: &output_app.world.resource::<AppTypeRegistry>().read(),
+            type_registry: &output_app.world().resource::<AppTypeRegistry>().read(),
         };
         deserialize(scene_deserializer, &serialized)
     };
 
-    let mut entity_map = EntityMap::default();
+    let mut entity_map = EntityHashMap::default();
     scene
-        .write_to_world(&mut output_app.world, &mut entity_map)
+        .write_to_world(&mut output_app.world_mut(), &mut entity_map)
         .unwrap_or_else(|error| panic!("Could not add deserialized scene to world: {error}"));
 
     // TODO: Ideally we'd check whether the input and output world are exactly equal. But the world does not implement Eq.
     //                         so instead we check the serialized outputs against each other. However, this will miss anything that fails to serialize in the first place.
 
-    let type_registry = input_app.world.resource::<AppTypeRegistry>();
-    let scene = DynamicScene::from_world(&input_app.world, type_registry);
-    let serialized_again = serialize(scene, type_registry);
+    let type_registry = input_app.world().resource::<AppTypeRegistry>().read();
+    let scene = DynamicScene::from_world(&input_app.world());
+    let serialized_again = serialize(scene, &type_registry);
 
     assert_eq!(serialized, serialized_again);
 }
 
-fn serialize_world_ron(scene: DynamicScene, type_registry: &AppTypeRegistry) -> Vec<u8> {
+fn serialize_world_ron(scene: DynamicScene, type_registry: &TypeRegistry) -> Vec<u8> {
     scene
-        .serialize_ron(type_registry)
+        .serialize(type_registry)
         .map(|output| output.as_bytes().to_vec())
         .unwrap_or_else(|error| panic!("Scene failed to serialize: {error}"))
 }
@@ -81,8 +82,8 @@ fn deserialize_world_ron(scene_deserializer: SceneDeserializer, input: &[u8]) ->
         .unwrap_or_else(|error| panic!("Scene failed to deserialize: {error}"))
 }
 
-fn serialize_world_postcard(scene: DynamicScene, type_registry: &AppTypeRegistry) -> Vec<u8> {
-    let scene_serializer = SceneSerializer::new(&scene, &type_registry.0);
+fn serialize_world_postcard(scene: DynamicScene, type_registry: &TypeRegistry) -> Vec<u8> {
+    let scene_serializer = SceneSerializer::new(&scene, type_registry);
     postcard::to_allocvec(&scene_serializer)
         .unwrap_or_else(|error| panic!("Scene failed to serialize: {error}"))
 }
@@ -94,8 +95,8 @@ fn deserialize_world_postcard(scene_deserializer: SceneDeserializer, input: &[u8
         .unwrap_or_else(|error| panic!("Scene failed to deserialize: {error}"))
 }
 
-fn serialize_world_bincode(scene: DynamicScene, type_registry: &AppTypeRegistry) -> Vec<u8> {
-    let scene_serializer = SceneSerializer::new(&scene, &type_registry.0);
+fn serialize_world_bincode(scene: DynamicScene, type_registry: &TypeRegistry) -> Vec<u8> {
+    let scene_serializer = SceneSerializer::new(&scene, type_registry);
     bincode::serialize(&scene_serializer)
         .unwrap_or_else(|error| panic!("Scene failed to serialize: {error}"))
 }
@@ -107,8 +108,8 @@ fn deserialize_world_bincode(scene_deserializer: SceneDeserializer, input: &[u8]
         .unwrap_or_else(|error| panic!("Scene failed to deserialize: {error}"))
 }
 
-fn serialize_world_messagepack(scene: DynamicScene, type_registry: &AppTypeRegistry) -> Vec<u8> {
-    let scene_serializer = SceneSerializer::new(&scene, &type_registry.0);
+fn serialize_world_messagepack(scene: DynamicScene, type_registry: &TypeRegistry) -> Vec<u8> {
+    let scene_serializer = SceneSerializer::new(&scene, type_registry);
     let mut buf = Vec::new();
     let mut ser = rmp_serde::Serializer::new(&mut buf);
     scene_serializer
@@ -130,33 +131,20 @@ fn deserialize_world_messagepack(
 
 fn create_test_app() -> App {
     let mut app = App::new();
-    app.add_plugins(MinimalPlugins)
-        .add_plugin(AssetPlugin::default())
-        .add_plugin(ScenePlugin::default())
-        .add_plugin(TransformPlugin::default())
-        .register_type::<ReferenceComponent>()
-        .register_type::<Option<Entity>>()
-        .register_type::<VectorComponent>()
-        .register_type::<TupleComponent>()
-        // TODO: Without the `Vec` registrations, the serialization
-        //      works. But the de-serialization fails. This does not sound correct.
-        //      Either both should fail, or both should work.
-        .register_type::<Vec<u32>>()
-        .register_type::<Vec<String>>()
-        // TODO: Without these tuple registrations, the serialization
-        //      works. But the de-serialization fails. This does not sound correct.
-        //      Either both should fail, or both should work.
-        .register_type::<(i32, String, f32)>()
-        .register_type::<(bool, bool, u32)>();
+    app.add_plugins(MinimalPlugins).add_plugins((
+        AssetPlugin::default(),
+        ScenePlugin,
+        TransformPlugin,
+    ));
 
     app
 }
 
 fn spawn_test_entities(app: &mut App) {
-    let entity_1 = app.world.spawn(TransformBundle::default()).id();
-    app.world.spawn(ReferenceComponent(Some(entity_1)));
+    let entity_1 = app.world_mut().spawn(Transform::default()).id();
+    app.world_mut().spawn(ReferenceComponent(Some(entity_1)));
 
-    app.world
+    app.world_mut()
         .spawn(VectorComponent {
             integer_vector: vec![1, 2, 3, 4, 5, 123456789],
             // Testing different characters in strings