From 38bd511efeca136461ab2ef1ffec5cbf6f78bb4c Mon Sep 17 00:00:00 2001 From: Raffaele Ragni Date: Tue, 9 Jul 2024 19:49:30 +0200 Subject: [PATCH] upgrade to bevy 0.14 --- Cargo.toml | 13 +++++----- src/binreflect.rs | 9 +++---- src/lib_priv.rs | 10 ++++---- src/networking/assets/mod.rs | 2 +- src/proto.rs | 3 ++- src/server/initial_sync.rs | 2 +- tests/assert/mod.rs | 40 +++++++++++++++++------------ tests/asset_sync.rs | 6 ++--- tests/component_sync.rs | 50 ++++++++++++++++++------------------ tests/entity_sync.rs | 24 ++++++++--------- tests/host_promotion.rs | 20 +++++++++------ tests/initial_sync.rs | 30 +++++++++++----------- tests/parent_sync.rs | 31 ++++++++++++---------- tests/setup/mod.rs | 27 ++++++++++--------- 14 files changed, 141 insertions(+), 126 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 1940313..0ac9fe9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,20 +16,21 @@ include = ["/src", "/LICENSE-MIT", "/LICENSE-APACHE"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -bevy = { version = "0.13" } -wgpu-types = { version = "0.19", features = ["serde", "replay", "trace"] } -bevy_renet = "0.0.11" +bevy = { version = "0.14" } +wgpu-types = { version = "0.20", features = ["serde"] } +bevy_renet = { git = "https://github.com/raffaeleragni/renet" } +#bevy_renet = "0.0.12" bincode = "1.3" serde = { version = "1.0", features = ["derive"] } -uuid = "1.8" +uuid = "1.10" threadpool = "1.8" tiny_http = { version = "0", default-features = false } -ureq = { version = "2.9", default-features = false } +ureq = { version = "2.10", default-features = false } portpicker = "0.1" ascii = "1.1" lz4-compress = "0.1" [dev-dependencies] -serial_test = "3.0" +serial_test = "3.1" bevy_editor_pls = "0.8" diff --git a/src/binreflect.rs b/src/binreflect.rs index c8d1ba4..15d7117 100644 --- a/src/binreflect.rs +++ b/src/binreflect.rs @@ -1,8 +1,7 @@ use bevy::reflect::{ - serde::{ReflectSerializer, UntypedReflectDeserializer}, + serde::{ReflectDeserializer, ReflectSerializer}, DynamicStruct, Reflect, ReflectFromReflect, TypeRegistry, }; - use bincode::{DefaultOptions, ErrorKind, Options}; use serde::de::DeserializeSeed; @@ -18,7 +17,7 @@ pub(crate) fn reflect_to_bin( } pub(crate) fn bin_to_reflect(data: &[u8], registry: &TypeRegistry) -> Box { - let reflect_deserializer = UntypedReflectDeserializer::new(registry); + let reflect_deserializer = ReflectDeserializer::new(registry); let binoptions = DefaultOptions::new() .with_fixint_encoding() .allow_trailing_bytes(); @@ -98,7 +97,7 @@ mod test { #[test] fn material_serde() { let material_orig = StandardMaterial { - base_color: Color::RED, + base_color: Color::srgb(1.0, 0.0, 0.0), ..StandardMaterial::default() }; @@ -124,7 +123,7 @@ mod test { #[test] fn reflect_material_no_dependencies() { let compo = StandardMaterial { - base_color: Color::RED, + base_color: Color::srgb(1.0, 0.0, 0.0), ..StandardMaterial::default() }; diff --git a/src/lib_priv.rs b/src/lib_priv.rs index 40c0883..3a69622 100644 --- a/src/lib_priv.rs +++ b/src/lib_priv.rs @@ -194,9 +194,9 @@ impl SyncComponent for App { ) -> &mut Self { self.register_type::(); self.register_type_data::(); - let c_id = self.world.init_component::(); - let c_exclude_id = self.world.init_component::>(); - let mut track = self.world.resource_mut::(); + let c_id = self.world_mut().init_component::(); + let c_exclude_id = self.world_mut().init_component::>(); + let mut track = self.world_mut().resource_mut::(); track.registered_componets_for_sync.insert(c_id); track .sync_exclude_cid_of_component_cid @@ -209,12 +209,12 @@ impl SyncComponent for App { } fn sync_materials(&mut self, enable: bool) { - let mut tracker = self.world.resource_mut::(); + let mut tracker = self.world_mut().resource_mut::(); tracker.sync_materials = enable; } fn sync_meshes(&mut self, enable: bool) { - let mut tracker = self.world.resource_mut::(); + let mut tracker = self.world_mut().resource_mut::(); tracker.sync_meshes = enable; } } diff --git a/src/networking/assets/mod.rs b/src/networking/assets/mod.rs index b7f73dc..bf0965a 100644 --- a/src/networking/assets/mod.rs +++ b/src/networking/assets/mod.rs @@ -14,12 +14,12 @@ use crate::{ lib_priv::SyncTrackerRes, networking::assets::image_serde::image_to_bin, proto::SyncAssetType, }; use ascii::AsciiString; -use bevy::utils::Uuid; use bevy::{prelude::*, utils::HashMap}; use mesh_serde::{bin_to_mesh, mesh_to_bin}; use std::io::Read; use threadpool::ThreadPool; use tiny_http::{Header, Request, Response, Server}; +use uuid::Uuid; use self::image_serde::bin_to_image; diff --git a/src/proto.rs b/src/proto.rs index e21d861..9e0a6dc 100644 --- a/src/proto.rs +++ b/src/proto.rs @@ -1,8 +1,9 @@ use std::net::IpAddr; -use bevy::{ecs::event::Event, utils::Uuid}; +use bevy::ecs::event::Event; use bevy_renet::renet::ClientId; use serde::{Deserialize, Serialize}; +use uuid::Uuid; pub type EntityId = Uuid; pub type AssId = Uuid; diff --git a/src/server/initial_sync.rs b/src/server/initial_sync.rs index 96ff97d..7dec1b2 100644 --- a/src/server/initial_sync.rs +++ b/src/server/initial_sync.rs @@ -4,9 +4,9 @@ use crate::{ binreflect::reflect_to_bin, lib_priv::SyncTrackerRes, networking::assets::SyncAssetTransfer, proto::Message, SyncEntity, }; -use bevy::utils::Uuid; use bevy::{prelude::*, utils::HashSet}; use bevy_renet::renet::{ClientId, DefaultChannel, RenetServer}; +use uuid::Uuid; pub(crate) fn send_initial_sync(client_id: ClientId, world: &mut World) { info!("Sending initial sync to client id {}", client_id); diff --git a/tests/assert/mod.rs b/tests/assert/mod.rs index fc5f0d1..5a21527 100644 --- a/tests/assert/mod.rs +++ b/tests/assert/mod.rs @@ -9,12 +9,12 @@ use crate::setup::{sample_image, sample_mesh, MySynched, TestEnv}; pub(crate) fn entities_in_sync(env: &mut TestEnv, _: T, entity_count: u32) { for c in &mut env.clients { let mut count_check = 0; - for e in c.world.query::<&SyncEntity>().iter(&c.world) { + for e in c.world_mut().query::<&SyncEntity>().iter(c.world()) { for se in env .server - .world + .world_mut() .query::<&SyncEntity>() - .iter(&env.server.world) + .iter(env.server.world()) { if se.uuid == e.uuid { count_check += 1; @@ -27,7 +27,7 @@ pub(crate) fn entities_in_sync(env: &mut TestEnv, _: T, entity_count: u32) { #[allow(dead_code)] pub(crate) fn no_messages_left_for_server(s: &mut App) { - let mut server = s.world.resource_mut::(); + let mut server = s.world_mut().resource_mut::(); for client_id in server.clients_id().into_iter() { assert!(server .receive_message(client_id, DefaultChannel::ReliableOrdered) @@ -44,7 +44,7 @@ pub(crate) fn no_messages_left_for_clients(cs: &mut Vec) { #[allow(dead_code)] pub(crate) fn no_messages_left_for_client(c: &mut App) { - let mut client = c.world.resource_mut::(); + let mut client = c.world_mut().resource_mut::(); assert!(client .receive_message(DefaultChannel::ReliableOrdered) .is_none()); @@ -53,8 +53,12 @@ pub(crate) fn no_messages_left_for_client(c: &mut App) { #[allow(dead_code)] pub(crate) fn initial_sync_for_client_happened(s: &mut App, c: &mut App, entity_count: u32) { let mut count_check = 0; - for (e, c) in c.world.query::<(&SyncEntity, &MySynched)>().iter(&c.world) { - for se in s.world.query::<&SyncEntity>().iter(&s.world) { + for (e, c) in c + .world_mut() + .query::<(&SyncEntity, &MySynched)>() + .iter(c.world()) + { + for se in s.world_mut().query::<&SyncEntity>().iter(s.world()) { if se.uuid == e.uuid { count_check += 1; assert_eq!(c.value, 7); @@ -68,9 +72,9 @@ pub(crate) fn initial_sync_for_client_happened(s: &mut App, c: &mut App, entity_ pub(crate) fn count_entities_with_component(app: &mut App) -> u32 { let mut count = 0; for _ in app - .world + .world_mut() .query_filtered::>() - .iter(&app.world) + .iter(app.world()) { count += 1; } @@ -81,9 +85,9 @@ pub(crate) fn count_entities_with_component(app: &mut App) -> u32 pub(crate) fn count_entities_without_component(app: &mut App) -> u32 { let mut count = 0; for _ in app - .world + .world_mut() .query_filtered::>() - .iter(&app.world) + .iter(app.world()) { count += 1; } @@ -92,19 +96,19 @@ pub(crate) fn count_entities_without_component(app: &mut App) -> u #[allow(dead_code)] pub(crate) fn get_first_entity_component(app: &mut App) -> Option<&T> { - app.world.query::<&T>().iter(&app.world).next() + app.world_mut().query::<&T>().iter(app.world()).next() } #[allow(dead_code)] pub(crate) fn material_has_color(app: &mut App, id: AssetId, color: Color) { - let materials = app.world.resource_mut::>(); + let materials = app.world_mut().resource_mut::>(); let material = materials.get(id).unwrap(); assert_eq!(material.base_color, color); } #[allow(dead_code)] pub(crate) fn assets_has_sample_mesh(app: &mut App, id: AssetId) { - let meshes = app.world.resource_mut::>(); + let meshes = app.world_mut().resource_mut::>(); let mesh = meshes.get(id).unwrap(); let sample = sample_mesh(); assert_eq!( @@ -120,7 +124,7 @@ pub(crate) fn assets_has_sample_mesh(app: &mut App, id: AssetId) { #[allow(dead_code)] pub(crate) fn assets_has_sample_image(app: &mut App, id: AssetId) { - let images = app.world.resource_mut::>(); + let images = app.world_mut().resource_mut::>(); let image = images.get(id).unwrap(); let sample = sample_image(); assert_eq!(image.data, sample.data); @@ -128,7 +132,11 @@ pub(crate) fn assets_has_sample_image(app: &mut App, id: AssetId) { #[allow(dead_code)] pub(crate) fn find_entity_with_server_id(app: &mut App, server_entity_id: Uuid) -> Option { - for (entity, sup) in app.world.query::<(Entity, &SyncEntity)>().iter(&app.world) { + for (entity, sup) in app + .world_mut() + .query::<(Entity, &SyncEntity)>() + .iter(app.world()) + { if sup.uuid == server_entity_id { return Some(entity); } diff --git a/tests/asset_sync.rs b/tests/asset_sync.rs index 574e2e0..ec7fe3b 100644 --- a/tests/asset_sync.rs +++ b/tests/asset_sync.rs @@ -21,7 +21,7 @@ fn sync_material_from_server() { spawn_new_material(app) }, |env, _, id| { - material_has_color(&mut env.clients[0], id, Color::RED); + material_has_color(&mut env.clients[0], id, Color::srgb(1.0, 0.0, 0.0)); }, ); } @@ -41,7 +41,7 @@ fn sync_material_from_client() { spawn_new_material(app) }, |env, _, id| { - material_has_color(&mut env.clients[0], id, Color::RED); + material_has_color(&mut env.clients[0], id, Color::srgb(1.0, 0.0, 0.0)); }, ); } @@ -61,7 +61,7 @@ fn sync_material_from_client_to_client_across_server() { spawn_new_material(app) }, |env, _, id| { - material_has_color(&mut env.clients[0], id, Color::RED); + material_has_color(&mut env.clients[0], id, Color::srgb(1.0, 0.0, 0.0)); }, ); } diff --git a/tests/component_sync.rs b/tests/component_sync.rs index 5027245..0c6e9ce 100644 --- a/tests/component_sync.rs +++ b/tests/component_sync.rs @@ -19,7 +19,7 @@ fn test_non_marked_component_is_not_transferred_from_server() { 1, TestRun::no_pre_setup, |env| { - env.server.world.spawn((SyncMark {}, MyNonSynched {})); + env.server.world_mut().spawn((SyncMark {}, MyNonSynched {})); 0 }, |env, _, _| { @@ -37,7 +37,7 @@ fn test_non_marked_component_is_not_transferred_from_client() { TestRun::no_pre_setup, |env| { env.clients[0] - .world + .world_mut() .spawn((SyncMark {}, MyNonSynched {})) .id() }, @@ -56,9 +56,9 @@ fn test_marked_component_is_transferred_from_server() { TestRun::no_pre_setup, |env| { env.setup_registration::(); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(4); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); }, |env, _, _| { @@ -76,17 +76,17 @@ fn test_marked_component_is_transferred_from_server_then_changed() { TestRun::no_pre_setup, |env: &mut TestEnv| { env.setup_registration::(); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(10); env.server - .world + .world_mut() .entity_mut(e_id) .insert(MySynched { value: 7 }); env.update(10); env.server - .world + .world_mut() .entity_mut(e_id) .get_mut::() .unwrap() @@ -110,16 +110,16 @@ fn test_marked_component_is_transferred_from_client() { TestRun::no_pre_setup, |env| { env.setup_registration::(); - let e_id = env.clients[0].world.spawn(SyncMark {}).id(); + let e_id = env.clients[0].world_mut().spawn(SyncMark {}).id(); env.update(4); - let mut e = env.clients[0].world.entity_mut(e_id); + let mut e = env.clients[0].world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); let server_e_id = e.get::().unwrap().uuid; server_e_id }, |env, _, id: Uuid| { let e = find_entity_with_server_id(&mut env.server, id).unwrap(); - let e = env.server.world.entity(e); + let e = env.server.world_mut().entity(e); let compo = e.get::().unwrap(); assert_eq!(compo.value, 7); }, @@ -134,15 +134,15 @@ fn test_marked_component_is_transferred_from_client_then_changed() { TestRun::no_pre_setup, |env: &mut TestEnv| { env.setup_registration::(); - let e_id = env.clients[0].world.spawn(SyncMark {}).id(); + let e_id = env.clients[0].world_mut().spawn(SyncMark {}).id(); env.update(3); - let mut e = env.clients[0].world.entity_mut(e_id); + let mut e = env.clients[0].world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); env.update(3); env.clients[0] - .world + .world_mut() .entity_mut(e_id) .get_mut::() .unwrap() @@ -150,7 +150,7 @@ fn test_marked_component_is_transferred_from_client_then_changed() { env.update(3); let server_e_id = env.clients[0] - .world + .world_mut() .entity_mut(e_id) .get::() .unwrap() @@ -159,7 +159,7 @@ fn test_marked_component_is_transferred_from_client_then_changed() { }, |env: &mut TestEnv, _, id: Uuid| { let e = find_entity_with_server_id(&mut env.server, id).unwrap(); - let e = env.server.world.entity(e); + let e = env.server.world_mut().entity(e); let compo = e.get::().unwrap(); assert_eq!(compo.value, 3); }, @@ -176,20 +176,20 @@ fn exclusion_marked_will_not_be_synced() { env.setup_registration::(); let e_id = env .server - .world + .world_mut() .spawn((SyncMark {}, SyncExclude::::default())) .id(); env.update(4); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); 0 }, |env, _, _| { let mut count_check = 0; for _ in env.clients[0] - .world + .world_mut() .query_filtered::>() - .iter(&env.clients[0].world) + .iter(env.clients[0].world()) { count_check += 1; } @@ -206,9 +206,9 @@ fn test_auto_spawn_for_global_transform() { TestRun::no_pre_setup, |env| { env.setup_registration::(); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(4); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(Transform::from_xyz(1.0, 2.0, 3.0)); }, |env, _, _| { @@ -230,9 +230,9 @@ fn test_auto_spawn_for_computed_visibility() { TestRun::no_pre_setup, |env| { env.setup_registration::(); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(4); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(VisibilityBundle::default()); }, |env, _, _| { @@ -250,9 +250,9 @@ fn test_auto_spawn_for_point_light() { TestRun::no_pre_setup, |env| { env.setup_registration::(); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(4); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(PointLightBundle::default()); }, |env, _, _| { diff --git a/tests/entity_sync.rs b/tests/entity_sync.rs index c69f505..095039f 100644 --- a/tests/entity_sync.rs +++ b/tests/entity_sync.rs @@ -15,7 +15,7 @@ fn test_one_entity_spawned_from_server() { 1, TestRun::no_pre_setup, |env| { - env.server.world.spawn(SyncMark {}); + env.server.world_mut().spawn(SyncMark {}); 1 }, assert::entities_in_sync, @@ -29,7 +29,7 @@ fn test_one_entity_spawned_from_client() { 1, TestRun::no_pre_setup, |env| { - env.clients[0].world.spawn(SyncMark {}); + env.clients[0].world_mut().spawn(SyncMark {}); 1 }, assert::entities_in_sync, @@ -43,9 +43,9 @@ fn test_more_entities_spawned_from_server() { 1, TestRun::no_pre_setup, |env| { - env.server.world.spawn(SyncMark {}); - env.server.world.spawn(SyncMark {}); - env.server.world.spawn(SyncMark {}); + env.server.world_mut().spawn(SyncMark {}); + env.server.world_mut().spawn(SyncMark {}); + env.server.world_mut().spawn(SyncMark {}); 3 }, assert::entities_in_sync, @@ -59,9 +59,9 @@ fn test_more_entities_spawned_from_client() { 1, TestRun::no_pre_setup, |env| { - env.clients[0].world.spawn(SyncMark {}); - env.clients[0].world.spawn(SyncMark {}); - env.clients[0].world.spawn(SyncMark {}); + env.clients[0].world_mut().spawn(SyncMark {}); + env.clients[0].world_mut().spawn(SyncMark {}); + env.clients[0].world_mut().spawn(SyncMark {}); 3 }, assert::entities_in_sync, @@ -75,9 +75,9 @@ fn test_entity_deleted_from_server() { 1, TestRun::no_pre_setup, |env| { - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(3); - env.server.world.entity_mut(e_id).despawn(); + env.server.world_mut().entity_mut(e_id).despawn(); 0 }, assert::entities_in_sync, @@ -91,9 +91,9 @@ fn test_entity_deleted_from_client() { 1, TestRun::no_pre_setup, |env| { - let e_id = env.clients[0].world.spawn(SyncMark {}).id(); + let e_id = env.clients[0].world_mut().spawn(SyncMark {}).id(); env.update(5); - let e = env.clients[0].world.entity_mut(e_id); + let e = env.clients[0].world_mut().entity_mut(e_id); let server_e_id = e.get::().unwrap().uuid; e.despawn(); server_e_id diff --git a/tests/host_promotion.rs b/tests/host_promotion.rs index 3ca20d1..cfa89c0 100644 --- a/tests/host_promotion.rs +++ b/tests/host_promotion.rs @@ -27,7 +27,7 @@ fn test_host_promotion_with_one_client() { assert_one_client_is_host(env); env.server - .world + .world_mut() .entity_mut(e_id) .get_mut::() .unwrap() @@ -45,9 +45,9 @@ fn test_host_promotion_with_one_client() { fn setup_and_check_sync(env: &mut TestEnv) -> Entity { env.setup_registration::(); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); env.update(4); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(MySynched { value: 1 }); env.update(4); assert!(!env.clients.is_empty()); @@ -56,7 +56,7 @@ fn setup_and_check_sync(env: &mut TestEnv) -> Entity { assert_eq!(comp.value, 1); } env.server - .world + .world_mut() .entity_mut(e_id) .get_mut::() .unwrap() @@ -78,15 +78,17 @@ fn alter_connection_port(env: &mut TestEnv) { } fn increment_port(app: &mut App) { - app.world.resource_mut::().port += 1; + app.world_mut() + .resource_mut::() + .port += 1; } fn send_promotion_event(env: &mut TestEnv) { - let server = env.server.world.resource_mut::(); + let server = env.server.world_mut().resource_mut::(); let event = PromoteToHostEvent { id: server.clients_id().first().unwrap().to_owned(), }; - env.server.world.send_event(event); + env.server.world_mut().send_event(event); } fn assert_server_is_host(env: &TestEnv) { @@ -108,5 +110,7 @@ fn assert_one_client_is_host(env: &TestEnv) { } fn is_host(app: &App) -> bool { - app.world.get_resource::().is_some() + app.world() + .get_resource::() + .is_some() } diff --git a/tests/initial_sync.rs b/tests/initial_sync.rs index b61b6ff..1a15ead 100644 --- a/tests/initial_sync.rs +++ b/tests/initial_sync.rs @@ -24,9 +24,9 @@ fn test_initial_world_sync_sent_from_server() { env.setup_registration::>(); env.server.sync_materials(true); env.server.sync_meshes(true); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); let id = spawn_new_material(&mut env.server); @@ -52,7 +52,7 @@ fn test_initial_world_sync_sent_from_server() { assert::no_messages_left_for_server(&mut env.server); assert::no_messages_left_for_client(&mut env.clients[0]); - material_has_color(&mut env.clients[0], id, Color::RED); + material_has_color(&mut env.clients[0], id, Color::srgb(1.0, 0.0, 0.0)); assets_has_sample_mesh(&mut env.clients[0], m_id); assets_has_sample_image(&mut env.clients[0], i_id); }, @@ -69,9 +69,9 @@ fn test_init_sync_multiple_clients() { env.setup_registration::>(); env.server.sync_materials(true); env.server.sync_meshes(true); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); let id = spawn_new_material(&mut env.server); @@ -85,7 +85,7 @@ fn test_init_sync_multiple_clients() { _| { for capp in &mut env.clients { assert::initial_sync_for_client_happened(&mut env.server, capp, entity_count); - material_has_color(capp, id, Color::RED); + material_has_color(capp, id, Color::srgb(1.0, 0.0, 0.0)); assets_has_sample_mesh(capp, m_id); } @@ -106,11 +106,11 @@ fn test_initial_world_sync_not_transfer_excluded_components() { env.server.sync_materials(true); let e_id = env .server - .world + .world_mut() .spawn((SyncMark {}, SyncExclude::::default())) .id(); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert(MySynched { value: 7 }); 0 @@ -133,7 +133,7 @@ fn test_initial_with_parenting() { env.setup_registration::(); let _ = env .server - .world + .world_mut() .spawn((SyncMark, MySynched { value: 7 })) .with_children(|parent| { parent.spawn((SyncMark, MySynched2 { value: 8 })); @@ -148,16 +148,16 @@ fn test_initial_with_parenting() { let app = &mut env.clients[0]; let entity_value = app - .world + .world_mut() .query_filtered::<&MySynched, Without>() - .iter(&app.world) + .iter(app.world()) .next(); assert_eq!(entity_value.unwrap().value, 7); let child_value = app - .world + .world_mut() .query_filtered::<&MySynched2, With>() - .iter(&app.world) + .iter(app.world()) .next(); assert_eq!(child_value.unwrap().value, 8); }, @@ -175,12 +175,12 @@ fn test_initial_world_sync_without_uuid() { env.setup_registration::>(); env.server.sync_materials(true); env.server.sync_meshes(true); - let e_id = env.server.world.spawn(SyncMark {}).id(); + let e_id = env.server.world_mut().spawn(SyncMark {}).id(); let material_id = spawn_new_material_nouuid(&mut env.server); let mesh_id = spawn_new_mesh_nouuid(&mut env.server); - let mut e = env.server.world.entity_mut(e_id); + let mut e = env.server.world_mut().entity_mut(e_id); e.insert((MySynched { value: 7 }, material_id, mesh_id)); 1 diff --git a/tests/parent_sync.rs b/tests/parent_sync.rs index c2a6ca1..413e86f 100644 --- a/tests/parent_sync.rs +++ b/tests/parent_sync.rs @@ -16,22 +16,22 @@ fn test_entity_parent_is_transferred_from_server() { 1, |_| {}, |env: &mut TestEnv| { - let e1 = env.server.world.spawn(SyncMark {}).id(); - let e2 = env.server.world.spawn(SyncMark {}).id(); + let e1 = env.server.world_mut().spawn(SyncMark {}).id(); + let e2 = env.server.world_mut().spawn(SyncMark {}).id(); env.update(3); - env.server.world.entity_mut(e1).add_child(e2); + env.server.world_mut().entity_mut(e1).add_child(e2); let server_e_id1 = env .server - .world + .world() .entity(e1) .get::() .unwrap() .uuid; let server_e_id2 = env .server - .world + .world() .entity(e2) .get::() .unwrap() @@ -45,7 +45,7 @@ fn test_entity_parent_is_transferred_from_server() { let child = find_entity_with_server_id(capp, entities.1) .expect("Children not found on client"); assert_eq!( - capp.world + capp.world() .entity(parent) .get::() .expect("Parent has no children component") @@ -55,7 +55,7 @@ fn test_entity_parent_is_transferred_from_server() { 1 ); assert_eq!( - capp.world + capp.world() .entity(child) .get::() .expect("Child has no parent component") @@ -77,18 +77,21 @@ fn test_entity_parent_is_transferred_from_client() { 1, |_| {}, |env: &mut TestEnv| { - let e_id1 = env.clients[0].world.spawn(SyncMark {}).id(); - let e_id2 = env.clients[0].world.spawn(SyncMark {}).id(); + let e_id1 = env.clients[0].world_mut().spawn(SyncMark {}).id(); + let e_id2 = env.clients[0].world_mut().spawn(SyncMark {}).id(); env.update(4); - env.clients[0].world.entity_mut(e_id1).add_child(e_id2); + env.clients[0] + .world_mut() + .entity_mut(e_id1) + .add_child(e_id2); env.update(4); - let e1 = &env.clients[0].world.entity(e_id1); + let e1 = &env.clients[0].world().entity(e_id1); let server_e1 = e1.get::().unwrap().uuid; - let e2 = &env.clients[0].world.entity(e_id2); + let e2 = &env.clients[0].world().entity(e_id2); let server_e2 = e2.get::().unwrap().uuid; (server_e1, server_e2) @@ -98,8 +101,8 @@ fn test_entity_parent_is_transferred_from_client() { let child = entities.1; let parent = find_entity_with_server_id(&mut env.server, parent).unwrap(); let child = find_entity_with_server_id(&mut env.server, child).unwrap(); - let parent = env.server.world.entity(parent); - let child = env.server.world.entity(child); + let parent = env.server.world().entity(parent); + let child = env.server.world().entity(child); assert_eq!( parent .get::() diff --git a/tests/setup/mod.rs b/tests/setup/mod.rs index fe0e31f..db6b2e3 100644 --- a/tests/setup/mod.rs +++ b/tests/setup/mod.rs @@ -11,13 +11,12 @@ use bevy::{ prelude::*, reflect::{DynamicTypePath, FromReflect, GetTypeRegistration, Reflect}, render::{mesh::Indices, render_asset::RenderAssetUsages, render_resource::PrimitiveTopology}, - transform::TransformBundle, - utils::Uuid, MinimalPlugins, }; use bevy_renet::renet::RenetClient; use bevy_sync::{ClientPlugin, ServerPlugin, SyncComponent, SyncPlugin}; use serde::{Deserialize, Serialize}; +use uuid::Uuid; #[derive(Component)] #[allow(dead_code)] // for some reason compiler thinks this is not used but it is @@ -143,7 +142,7 @@ fn create_server() -> Result> { let mut sapp = App::new(); add_plugins(&mut sapp); // Start a non synched entity only on server so the id is intentionally offseted between server and client - sapp.world.spawn(TransformBundle::default()); + sapp.world_mut().spawn(TransformBundle::default()); Ok(sapp) } @@ -205,7 +204,7 @@ fn wait_until_connected( while count < updates { sapp.update(); capp.update(); - if !capp.world.resource::().is_disconnected() { + if !capp.world().resource::().is_disconnected() { return Ok(()); } count += 1; @@ -216,58 +215,58 @@ fn wait_until_connected( #[allow(dead_code)] pub(crate) fn spawn_new_material(app: &mut App) -> AssetId { - let mut materials = app.world.resource_mut::>(); + let mut materials = app.world_mut().resource_mut::>(); let id = Uuid::new_v4(); let material = StandardMaterial { - base_color: Color::RED, + base_color: Color::srgb(1.0, 0.0, 0.0), ..Default::default() }; let handle = Handle::::Weak(id.into()); materials.insert(id, material); - app.world.spawn(handle); + app.world_mut().spawn(handle); id.into() } #[allow(dead_code)] pub(crate) fn spawn_new_mesh(app: &mut App) -> AssetId { - let mut meshes = app.world.resource_mut::>(); + let mut meshes = app.world_mut().resource_mut::>(); let id = Uuid::new_v4(); let mesh = sample_mesh(); let handle = Handle::::Weak(id.into()); meshes.insert(id, mesh); - app.world.spawn(handle); + app.world_mut().spawn(handle); id.into() } #[allow(dead_code)] pub(crate) fn spawn_new_image(app: &mut App) -> AssetId { - let mut images = app.world.resource_mut::>(); + let mut images = app.world_mut().resource_mut::>(); let id = Uuid::new_v4(); let mesh = sample_image(); let handle = Handle::::Weak(id.into()); images.insert(id, mesh); - app.world.spawn(handle); + app.world_mut().spawn(handle); id.into() } #[allow(dead_code)] pub(crate) fn spawn_new_material_nouuid(app: &mut App) -> Handle { - let mut materials = app.world.resource_mut::>(); + let mut materials = app.world_mut().resource_mut::>(); materials.add(StandardMaterial { - base_color: Color::RED, + base_color: Color::srgb(1.0, 0.0, 0.0), ..Default::default() }) } #[allow(dead_code)] pub(crate) fn spawn_new_mesh_nouuid(app: &mut App) -> Handle { - let mut meshes = app.world.resource_mut::>(); + let mut meshes = app.world_mut().resource_mut::>(); meshes.add(sample_mesh()) }